elxElastixMain.cxx

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

  This file is part of the elastix software.

  Copyright (c) University Medical Center Utrecht. All rights reserved.
  See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php for
  details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE. See the above copyright notices for more information.

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

#if defined( _WIN32 ) && !defined( __CYGWIN__ )
#include <windows.h>
#endif

#include "elxElastixMain.h"
#include "elxMacro.h"
#include "itkMultiThreader.h"

namespace elastix
{

using namespace xl;

xoutbase_type   g_xout;
xoutsimple_type g_WarningXout;
xoutsimple_type g_ErrorXout;
xoutsimple_type g_StandardXout;
xoutsimple_type g_CoutOnlyXout;
xoutsimple_type g_LogOnlyXout;
std::ofstream   g_LogFileStream;

int
xoutSetup( const char * logfilename, bool setupLogging, bool setupCout )
{
    using namespace xl;

    int returndummy = 0;
    set_xout( &g_xout );

    if( setupLogging )
    {
        g_LogFileStream.open( logfilename );
        if( !g_LogFileStream.is_open() )
        {
            std::cerr << "ERROR: LogFile cannot be opened!" << std::endl;
            return 1;
        }
    }

    if( setupLogging )
    {
        returndummy |= xout.AddOutput( "log", &g_LogFileStream );
    }
    if( setupCout )
    {
        returndummy |= xout.AddOutput( "cout", &std::cout );
    }

    returndummy |= g_LogOnlyXout.AddOutput( "log", &g_LogFileStream );
    returndummy |= g_CoutOnlyXout.AddOutput( "cout", &std::cout );

    g_WarningXout.SetOutputs( xout.GetCOutputs() );
    g_ErrorXout.SetOutputs( xout.GetCOutputs() );
    g_StandardXout.SetOutputs( xout.GetCOutputs() );

    g_WarningXout.SetOutputs( xout.GetXOutputs() );
    g_ErrorXout.SetOutputs( xout.GetXOutputs() );
    g_StandardXout.SetOutputs( xout.GetXOutputs() );

    returndummy |= xout.AddTargetCell( "warning", &g_WarningXout );
    returndummy |= xout.AddTargetCell( "error", &g_ErrorXout );
    returndummy |= xout.AddTargetCell( "standard", &g_StandardXout );
    returndummy |= xout.AddTargetCell( "logonly", &g_LogOnlyXout );
    returndummy |= xout.AddTargetCell( "coutonly", &g_CoutOnlyXout );

    xout[ "standard" ] << std::fixed;
    xout[ "standard" ] << std::showpoint;

    return returndummy;

} // end xoutSetup()



ElastixMain::ElastixMain()
{
    this->m_Configuration = ConfigurationType::New();

    this->m_Elastix = 0;

    this->m_FixedImagePixelType = "";
    this->m_FixedImageDimension = 0;

    this->m_MovingImagePixelType = "";
    this->m_MovingImageDimension = 0;

    this->m_DBIndex = 0;

    this->m_FixedImageContainer  = 0;
    this->m_MovingImageContainer = 0;

    this->m_FixedMaskContainer  = 0;
    this->m_MovingMaskContainer = 0;

    this->m_ResultImageContainer = 0;

    this->m_FinalTransform   = 0;
    this->m_InitialTransform = 0;
    this->m_TransformParametersMap.clear();

} // end Constructor


ElastixMain::ComponentDatabasePointer ElastixMain::s_CDB             = 0;
ElastixMain::ComponentLoaderPointer   ElastixMain::s_ComponentLoader = 0;

ElastixMain::~ElastixMain()
{
    //nothing
} // end Destructor


void
ElastixMain
::EnterCommandLineArguments( ArgumentMapType & argmap )
{

    int dummy = this->m_Configuration->Initialize( argmap );
    if( dummy )
    {
        xout[ "error" ] << "ERROR: Something went wrong during initialisation "
                        << "of the configuration object." << std::endl;
    }

} // end EnterCommandLineParameters()


void
ElastixMain
::EnterCommandLineArguments( ArgumentMapType & argmap,
                             ParameterMapType & inputMap )
{
    int dummy = this->m_Configuration->Initialize( argmap, inputMap );
    if( dummy )
    {
        xout[ "error" ] << "ERROR: Something went wrong during initialisation of the configuration object." << std::endl;
    }

} // end EnterCommandLineArguments()


void
ElastixMain
::EnterCommandLineArguments( ArgumentMapType & argmap,
                             std::vector< ParameterMapType > & inputMaps )
{
    this->m_Configurations.clear();
    this->m_Configurations.resize( inputMaps.size() );

    for( size_t i = 0; i < inputMaps.size(); ++i )
    {
        this->m_Configurations[ i ] = ConfigurationType::New();
        int dummy = this->m_Configurations[ i ]->Initialize( argmap, inputMaps[ i ] );
        if( dummy )
        {
            xout[ "error" ] << "ERROR: Something went wrong during initialisation of configuration object " << i << "." << std::endl;
        }
    }

    this->m_Configuration = this->m_Configurations[ inputMaps.size() - 1 ];
} // end EnterCommandLineArguments()


int
ElastixMain::Run( void )
{

    this->SetProcessPriority();
    this->SetMaximumNumberOfThreads();

    int errorCode = this->InitDBIndex();
    if( errorCode != 0 )
    {
        return errorCode;
    }

    try
    {
        this->m_Elastix = this->CreateComponent( "Elastix" );
    }
    catch( itk::ExceptionObject & excp )
    {
        xl::xout[ "error" ] << excp << std::endl;
        errorCode = 1;
        return errorCode;
    }

    this->GetElastixBase()->SetConfiguration( this->m_Configuration );
    this->GetElastixBase()->SetComponentDatabase( this->s_CDB );
    this->GetElastixBase()->SetDBIndex( this->m_DBIndex );

    this->GetElastixBase()->SetRegistrationContainer(
        this->CreateComponents( "Registration", "MultiResolutionRegistration",
                                errorCode ) );

    this->GetElastixBase()->SetFixedImagePyramidContainer(
        this->CreateComponents( "FixedImagePyramid", "FixedSmoothingImagePyramid",
                                errorCode ) );

    this->GetElastixBase()->SetMovingImagePyramidContainer(
        this->CreateComponents( "MovingImagePyramid", "MovingSmoothingImagePyramid",
                                errorCode ) );

    this->GetElastixBase()->SetImageSamplerContainer(
        this->CreateComponents( "ImageSampler", "", errorCode, false ) );

    this->GetElastixBase()->SetInterpolatorContainer(
        this->CreateComponents( "Interpolator", "BSplineInterpolator",
                                errorCode ) );

    this->GetElastixBase()->SetMetricContainer(
        this->CreateComponents( "Metric", "", errorCode ) );

    this->GetElastixBase()->SetOptimizerContainer(
        this->CreateComponents( "Optimizer", "", errorCode ) );

    this->GetElastixBase()->SetResampleInterpolatorContainer(
        this->CreateComponents( "ResampleInterpolator", "FinalBSplineInterpolator",
                                errorCode ) );

    this->GetElastixBase()->SetResamplerContainer(
        this->CreateComponents( "Resampler", "DefaultResampler",
                                errorCode ) );

    this->GetElastixBase()->SetTransformContainer(
        this->CreateComponents( "Transform", "", errorCode ) );

    if( errorCode != 0 )
    {
        xout[ "error" ] << "ERROR:" << std::endl;
        xout[ "error" ] << "One or more components could not be created." << std::endl;
        return 1;
    }

    this->GetElastixBase()->SetFixedImageContainer( this->GetFixedImageContainer() );
    this->GetElastixBase()->SetMovingImageContainer( this->GetMovingImageContainer() );
    this->GetElastixBase()->SetFixedMaskContainer( this->GetFixedMaskContainer() );
    this->GetElastixBase()->SetMovingMaskContainer( this->GetMovingMaskContainer() );
    this->GetElastixBase()->SetResultImageContainer( this->GetResultImageContainer() );

    this->GetElastixBase()->SetInitialTransform( this->GetInitialTransform() );

    this->GetElastixBase()->SetOriginalFixedImageDirectionFlat(
        this->GetOriginalFixedImageDirectionFlat() );

    try
    {
        errorCode = this->GetElastixBase()->Run();
    }
    catch( itk::ExceptionObject & excp1 )
    {
        xl::xout[ "error" ] << excp1 << std::endl;
        errorCode = 1;
    }
    catch( std::exception & excp2 )
    {
        xl::xout[ "error" ] << "std: " << excp2.what() << std::endl;
        errorCode = 1;
    }
    catch( ... )
    {
        xl::xout[ "error" ] << "ERROR: an unknown non-ITK, non-std exception was caught.\n"
                            << "Please report this to elastix@bigr.nl." << std::endl;
        errorCode = 1;
    }

    this->m_FinalTransform = this->GetElastixBase()->GetFinalTransform();

    this->m_TransformParametersMap = this->GetElastixBase()->GetTransformParametersMap();

    this->SetFixedImageContainer( this->GetElastixBase()->GetFixedImageContainer() );
    this->SetMovingImageContainer( this->GetElastixBase()->GetMovingImageContainer() );
    this->SetFixedMaskContainer( this->GetElastixBase()->GetFixedMaskContainer() );
    this->SetMovingMaskContainer( this->GetElastixBase()->GetMovingMaskContainer() );
    this->SetResultImageContainer( this->GetElastixBase()->GetResultImageContainer() );

    this->SetOriginalFixedImageDirectionFlat(
        this->GetElastixBase()->GetOriginalFixedImageDirectionFlat() );

    return errorCode;

} // end Run()


int
ElastixMain::Run( ArgumentMapType & argmap )
{
    this->EnterCommandLineArguments( argmap );
    return this->Run();
} // end Run()


int
ElastixMain
::Run( ArgumentMapType & argmap,
       ParameterMapType & inputMap )
{
    this->EnterCommandLineArguments( argmap, inputMap );
    return this->Run();
} // end Run()


int
ElastixMain::InitDBIndex( void )
{
    if( this->m_Configuration->IsInitialized() )
    {
        if( this->m_FixedImagePixelType.empty() )
        {
            this->m_FixedImagePixelType = "float"; // \note: this assumes elastix was compiled for float
            this->m_Configuration->ReadParameter( this->m_FixedImagePixelType,
                                                  "FixedInternalImagePixelType", 0 );
        }

        if( this->m_FixedImageDimension == 0 )
        {
#ifndef _ELASTIX_BUILD_LIBRARY

            std::string fixedImageFileName
                = this->m_Configuration->GetCommandLineArgument( "-f" );
            if( fixedImageFileName == "" )
            {
                fixedImageFileName = this->m_Configuration->GetCommandLineArgument( "-f0" );
            }
            try
            {
                this->GetImageInformationFromFile( fixedImageFileName,
                                                   this->m_FixedImageDimension );
            }
            catch( itk::ExceptionObject & err )
            {
                xout[ "error" ] << "ERROR: could not read fixed image." << std::endl;
                xout[ "error" ] << err << std::endl;
                return 1;
            }

            unsigned int fixDimParameterFile  = 0;
            bool         foundInParameterFile = this->m_Configuration->ReadParameter( fixDimParameterFile,
                                                "FixedImageDimension", 0, false );

            if( foundInParameterFile )
            {
                if( fixDimParameterFile != this->m_FixedImageDimension )
                {
                    xout[ "error" ] << "ERROR: problem defining fixed image dimension.\n"
                                    << "  The parameter file says:     " << fixDimParameterFile << "\n"
                                    << "  The fixed image header says: " << this->m_FixedImageDimension << "\n"
                                    << "  Note that from elastix 4.6 the parameter file definition \"FixedImageDimension\" "
                                    << "is not needed anymore.\n  Please remove this entry from your parameter file."
                                    << std::endl;
                    return 1;
                }
            }
#else
            this->m_Configuration->ReadParameter( this->m_FixedImageDimension,
                                                  "FixedImageDimension", 0, false );
#endif

            if( this->m_FixedImageDimension == 0 )
            {
                xout[ "error" ] << "ERROR:" << std::endl;
                xout[ "error" ] << "The FixedImageDimension is not given." << std::endl;
                return 1;
            }
        }

        if( this->m_MovingImagePixelType.empty() )
        {
            this->m_MovingImagePixelType = "float"; // \note: this assumes elastix was compiled for float
            this->m_Configuration->ReadParameter( this->m_MovingImagePixelType,
                                                  "MovingInternalImagePixelType", 0 );
        }

        if( this->m_MovingImageDimension == 0 )
        {
#ifndef _ELASTIX_BUILD_LIBRARY

            std::string movingImageFileName
                = this->m_Configuration->GetCommandLineArgument( "-m" );
            if( movingImageFileName == "" )
            {
                movingImageFileName = this->m_Configuration->GetCommandLineArgument( "-m0" );
            }
            try
            {
                this->GetImageInformationFromFile( movingImageFileName,
                                                   this->m_MovingImageDimension );
            }
            catch( itk::ExceptionObject & err )
            {
                xout[ "error" ] << "ERROR: could not read moving image." << std::endl;
                xout[ "error" ] << err << std::endl;
                return 1;
            }

            unsigned int movDimParameterFile  = 0;
            bool         foundInParameterFile = this->m_Configuration->ReadParameter( movDimParameterFile,
                                                "MovingImageDimension", 0, false );

            if( foundInParameterFile )
            {
                if( movDimParameterFile != this->m_MovingImageDimension )
                {
                    xout[ "error" ] << "ERROR: problem defining moving image dimension.\n"
                                    << "  The parameter file says:      " << movDimParameterFile << "\n"
                                    << "  The moving image header says: " << this->m_MovingImageDimension << "\n"
                                    << "  Note that from elastix 4.6 the parameter file definition \"MovingImageDimension\" "
                                    << "is not needed anymore.\n  Please remove this entry from your parameter file."
                                    << std::endl;
                    return 1;
                }
            }

#else
            this->m_Configuration->ReadParameter( this->m_MovingImageDimension,
                                                  "MovingImageDimension", 0, false );
#endif

            if( this->m_MovingImageDimension == 0 )
            {
                xout[ "error" ] << "ERROR:" << std::endl;
                xout[ "error" ] << "The MovingImageDimension is not given." << std::endl;
                return 1;
            }
        }

        if( this->s_CDB.IsNull() )
        {
            int loadReturnCode = this->LoadComponents();
            if( loadReturnCode != 0 )
            {
                xout[ "error" ] << "Loading components failed" << std::endl;
                return loadReturnCode;
            }
        }

        if( this->s_CDB.IsNotNull() )
        {
            this->m_DBIndex = this->s_CDB->GetIndex(
                                  this->m_FixedImagePixelType,
                                  this->m_FixedImageDimension,
                                  this->m_MovingImagePixelType,
                                  this->m_MovingImageDimension );
            if( this->m_DBIndex == 0 )
            {
                xout[ "error" ] << "ERROR:" << std::endl;
                xout[ "error" ] << "Something went wrong in the ComponentDatabase" << std::endl;
                return 1;
            }
        } // end if s_CDB!=0

    } // end if m_Configuration->Initialized();
    else
    {
        xout[ "error" ] << "ERROR:" << std::endl;
        xout[ "error" ] << "The configuration object has not been initialized." << std::endl;
        return 1;
    }

    return 0;

} // end InitDBIndex()


void
ElastixMain::SetElastixLevel( unsigned int level )
{
    this->m_Configuration->SetElastixLevel( level );

} // end SetElastixLevel()


unsigned int
ElastixMain::GetElastixLevel( void )
{
    return this->m_Configuration->GetElastixLevel();

} // end GetElastixLevel()


void
ElastixMain::SetTotalNumberOfElastixLevels( unsigned int levels )
{
    this->m_Configuration->SetTotalNumberOfElastixLevels( levels );

} // end SetTotalNumberOfElastixLevels()


unsigned int
ElastixMain::GetTotalNumberOfElastixLevels( void )
{
    return this->m_Configuration->GetTotalNumberOfElastixLevels();

} // end GetTotalNumberOfElastixLevels()


int
ElastixMain::LoadComponents( void )
{
    if( this->s_CDB.IsNull() )
    {
        this->s_CDB = ComponentDatabaseType::New();
    }

    if( this->s_ComponentLoader.IsNull() )
    {
        this->s_ComponentLoader = ComponentLoaderType::New();
        this->s_ComponentLoader->SetComponentDatabase( s_CDB );
    }

    const char * argv0
        = this->m_Configuration->GetCommandLineArgument( "-argv0" ).c_str();

    return this->s_ComponentLoader->LoadComponents( argv0 );

} // end LoadComponents()


void
ElastixMain::UnloadComponents( void )
{
    s_CDB = 0;
    s_ComponentLoader->SetComponentDatabase( 0 );

    if( s_ComponentLoader )
    {
        s_ComponentLoader->UnloadComponents();
    }

    s_ComponentLoader = 0;

} // end UnloadComponents()


ElastixMain::ElastixBaseType *
ElastixMain::GetElastixBase( void ) const
{
    ElastixBaseType * testpointer;

    testpointer = dynamic_cast< ElastixBaseType * >( this->m_Elastix.GetPointer() );
    if( !testpointer )
    {
        itkExceptionMacro( << "Probably GetElastixBase() is called before having called Run()" );
    }

    return testpointer;

} // end GetElastixBase()


ElastixMain::ObjectPointer
ElastixMain::CreateComponent(
    const ComponentDescriptionType & name )
{
    PtrToCreator  testcreator = 0;
    ObjectPointer testpointer = 0;
    testcreator = this->s_CDB->GetCreator( name,  this->m_DBIndex );
    testpointer = testcreator ? testcreator() : NULL;
    if( testpointer.IsNull() )
    {
        itkExceptionMacro( << "The following component could not be created: " << name );
    }

    return testpointer;

} // end CreateComponent()


ElastixMain::ObjectContainerPointer
ElastixMain::CreateComponents(
    const std::string & key,
    const ComponentDescriptionType & defaultComponentName,
    int & errorcode, bool mandatoryComponent )
{
    ComponentDescriptionType componentName   = defaultComponentName;
    unsigned int             componentnr     = 0;
    ObjectContainerPointer   objectContainer = ObjectContainerType::New();
    objectContainer->Initialize();

    bool found = this->m_Configuration->ReadParameter(
                     componentName, key, componentnr, true );

    if( !found && ( defaultComponentName == "" ) )
    {
        if( mandatoryComponent )
        {
            xout[ "error" ]
                    << "ERROR: the following component has not been specified: "
                    << key << std::endl;
            errorcode = 1;
            return objectContainer;
        }
        else
        {
            /* Just return an empty container without nagging. */
            errorcode = 0;
            return objectContainer;
        }
    }

    try
    {
        objectContainer->CreateElementAt( componentnr )
            = this->CreateComponent( componentName );
    }
    catch( itk::ExceptionObject & excp )
    {
        xout[ "error" ]
                << "ERROR: error occurred while creating "
                << key << " "
                << componentnr << "." << std::endl;
        xout[ "error" ] << excp << std::endl;
        errorcode = 1;
        return objectContainer;
    }

    while( found )
    {
        ++componentnr;
        found = this->m_Configuration->ReadParameter(
                    componentName, key, componentnr, false );
        if( found )
        {
            try
            {
                objectContainer->CreateElementAt( componentnr )
                    = this->CreateComponent( componentName );
            }
            catch( itk::ExceptionObject & excp )
            {
                xout[ "error" ]
                        << "ERROR: error occurred while creating "
                        << key << " "
                        << componentnr  << "." << std::endl;
                xout[ "error" ] << excp << std::endl;
                errorcode = 1;
                return objectContainer;
            }
        } // end if
    }   // end while

    return objectContainer;

} // end CreateComponents()


void
ElastixMain::SetProcessPriority( void ) const
{
    std::string processPriority = "";
    processPriority = this->m_Configuration->GetCommandLineArgument( "-priority" );
    if( processPriority == "high" )
    {
#if defined( _WIN32 ) && !defined( __CYGWIN__ )
        SetPriorityClass( GetCurrentProcess(), HIGH_PRIORITY_CLASS );
#endif
    }
    else if( processPriority == "abovenormal" )
    {
#if defined( _WIN32 ) && !defined( __CYGWIN__ )
        SetPriorityClass( GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS );
#endif
    }
    else if( processPriority == "normal" )
    {
#if defined( _WIN32 ) && !defined( __CYGWIN__ )
        SetPriorityClass( GetCurrentProcess(), NORMAL_PRIORITY_CLASS );
#endif
    }
    else if( processPriority == "belownormal" )
    {
#if defined( _WIN32 ) && !defined( __CYGWIN__ )
        SetPriorityClass( GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS );
#endif
    }
    else if( processPriority == "idle" )
    {
#if defined( _WIN32 ) && !defined( __CYGWIN__ )
        SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
#endif
    }
    else if( processPriority != "" )
    {
        xl::xout[ "warning" ]
                << "Unsupported -priority value. Specify one of <high, abovenormal, normal, belownormal, idle, ''>." << std::endl;
    }

} // end SetProcessPriority()


void
ElastixMain::SetMaximumNumberOfThreads( void ) const
{
    std::string maximumNumberOfThreadsString = "";
    maximumNumberOfThreadsString
        = this->m_Configuration->GetCommandLineArgument( "-threads" );

    if( maximumNumberOfThreadsString != "" )
    {
        const int maximumNumberOfThreads
            = atoi( maximumNumberOfThreadsString.c_str() );
        itk::MultiThreader::SetGlobalMaximumNumberOfThreads(
            maximumNumberOfThreads );
    }
} // end SetMaximumNumberOfThreads()


void
ElastixMain::SetOriginalFixedImageDirectionFlat(
    const FlatDirectionCosinesType & arg )
{
    this->m_OriginalFixedImageDirection = arg;
} // end SetOriginalFixedImageDirectionFlat()


const ElastixMain::FlatDirectionCosinesType &
ElastixMain::GetOriginalFixedImageDirectionFlat( void ) const
{
    return this->m_OriginalFixedImageDirection;
} // end GetOriginalFixedImageDirectionFlat()


ElastixMain::ParameterMapType
ElastixMain::GetTransformParametersMap( void ) const
{
    return this->m_TransformParametersMap;
} // end GetTransformParametersMap()


void
ElastixMain::GetImageInformationFromFile(
    const std::string & filename,
    ImageDimensionType & imageDimension ) const
{
    if( filename != "" )
    {
        const unsigned int DummyDimension = 3;
        typedef short                                        DummyPixelType;
        typedef itk::Image< DummyPixelType, DummyDimension > DummyImageType;

        typedef itk::ImageFileReader< DummyImageType > ReaderType;
        ReaderType::Pointer testReader = ReaderType::New();
        testReader->SetFileName( filename.c_str() );

        testReader->GenerateOutputInformation();

        itk::ImageIOBase::Pointer testImageIO = testReader->GetImageIO();
        //itk::ImageIOBase::IOComponentType componentType = testImageIO->GetComponentType();
        //pixelType = itk::ImageIOBase::GetComponentTypeAsString( componentType );
        if( testImageIO.IsNull() )
        {
            itkExceptionMacro( << "ERROR: ImageIO object was not created, but no exception was thrown." );
        }
        imageDimension = testImageIO->GetNumberOfDimensions();
    } // end if

} // end GetImageInformationFromFile()


} // end namespace elastix