ITK  4.6.0
Insight Segmentation and Registration Toolkit
IO/XML/itkParticleSwarmOptimizerSAXReader.cxx
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#include "itkParticleSwarmOptimizerSAXReader.h"
#include "itksys/SystemTools.hxx"
#include <sstream>
namespace itk
{
int ParticleSwarmOptimizerSAXReader::CanReadFile( const char* name )
{
std::ifstream ifs( name );
int yes = ifs.is_open();
if (yes)
{
ifs.close();
}
return yes;
}
void ParticleSwarmOptimizerSAXReader::StartElement( const char* name, const char** atts )
{
if ( itksys::SystemTools::Strucmp( name, "optimizer" ) == 0 && this->ContextIs( "/" ) )
{
this->ProcessOptimizerAttributes( atts, this->m_OutputObject );
}
else if ( itksys::SystemTools::Strucmp( name, "bound" ) == 0 && this->ContextIs( "/optimizer" ) )
{
std::vector<double>* bound = 0;
const char* id = this->GetAttribute( atts, "id" );
if ( id == 0 )
{
itkExceptionMacro( "Bound ID is missing!\n" );
}
else if ( itksys::SystemTools::Strucmp( id, "lower" ) == 0 )
{
bound = &this->m_LowerBound;
}
else if ( itksys::SystemTools::Strucmp( id, "upper" ) == 0 )
{
bound = &this->m_UpperBound;
}
else
{
itkExceptionMacro( "Bad attribute for bound:" << id);
}
this->ProcessBoundAttributes( atts, *bound );
}
else if ( itksys::SystemTools::Strucmp( name, "ParametersConvergenceTolerance" ) == 0 && this->ContextIs( "/optimizer" ) )
{
// nothing to do as it does not have attributes
}
this->m_CurrentTags.push_back( name );
}
void ParticleSwarmOptimizerSAXReader::EndElement( const char* name )
{
if ( itksys::SystemTools::Strucmp( name, "optimizer" ) == 0 && this->ContextIs( "/optimizer" ) )
{
// all children have been read, now incorporate them into the output object
for ( size_t i = 0; i < this->m_LowerBound.size(); i++ )
{
std::pair<double,double> value;
value.first = this->m_LowerBound[i];
value.second = this->m_UpperBound[i];
bounds.push_back( value );
}
this->m_OutputObject->SetParameterBounds( bounds );
this->m_OutputObject->SetParametersConvergenceTolerance( this->m_ParametersConvergenceTolerance );
}
else if ( itksys::SystemTools::Strucmp( name, "bound" ) == 0 && this->ContextIs( "/optimizer/bound" ) )
{
// nothing to do as it does not have children
}
else if ( itksys::SystemTools::Strucmp( name, "ParametersConvergenceTolerance" ) == 0 && this->ContextIs( "/optimizer/ParametersConvergenceTolerance" ) )
{
// nothing to do as it does not have children
}
this->m_CurrentTags.pop_back();
}
void ParticleSwarmOptimizerSAXReader::CharacterDataHandler( const char* inData, int inLength )
{
if ( this->ContextIs( "/optimizer/ParametersConvergenceTolerance" ) )
{
std::vector<double> data;
std::string s( inData, inLength );
std::istringstream iss( s );
while ( iss.good() )
{
double value = 0;
iss >> value;
data.push_back( value );
}
Array<double> ptols( data.size() );
for ( size_t i = 0; i < data.size(); i++ )
{
ptols[i] = data[i];
}
this->m_ParametersConvergenceTolerance = ptols;
}
}
int ParticleSwarmOptimizerSAXReader::ReadFile()
{
try
{
if ( !this->CanReadFile( this->m_Filename.c_str() ) )
{
// itkExceptionMacro does not accept a variable as the input,
// so the following is needed if we want to include the file name in the exception message
ExceptionObject e( __FILE__, __LINE__ );
std::string message = "Cannot read from ";
message += this->m_Filename;
message += "!\n";
e.SetDescription( message.c_str() );
throw e;
}
if ( this->m_OutputObject == 0 )
{
itkExceptionMacro( "Object to be read is null!\n" );
}
this->m_CurrentTags.clear();
// the real work is performed in this method
this->GenerateOutputInformation();
return 1;
}
catch (...)
{
return 0;
}
}
void ParticleSwarmOptimizerSAXReader::ProcessOptimizerAttributes( const char** atts, ParticleSwarmOptimizer* opt )
{
// go over all the attribute-value pairs
for ( size_t i = 0; atts[i] != 0; i += 2 )
{
if ( itksys::SystemTools::Strucmp( atts[i], "NumberOfParticles" ) == 0 )
{
std::istringstream iss( atts[i+1] );
int nop = 0;
iss >> nop;
opt->SetNumberOfParticles( nop );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "MaximumNumberOfIterations" ) == 0 )
{
std::istringstream iss( atts[i+1] );
int noi = 0;
iss >> noi;
opt->SetMaximalNumberOfIterations( noi );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "InertiaCoefficient" ) == 0 )
{
std::istringstream iss( atts[i+1] );
double icoef = 0;
iss >> icoef;
opt->SetInertiaCoefficient( icoef );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "GlobalCoefficient" ) == 0 )
{
std::istringstream iss( atts[i+1] );
double gcoef = 0;
iss >> gcoef;
opt->SetGlobalCoefficient( gcoef );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "PersonalCoefficient" ) == 0 )
{
std::istringstream iss( atts[i+1] );
double pcoef = 0;
iss >> pcoef;
opt->SetPersonalCoefficient( pcoef );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "FunctionConvergenceTolerance" ) == 0 )
{
std::istringstream iss( atts[i+1] );
double ftol = 0;
iss >> ftol;
opt->SetFunctionConvergenceTolerance( ftol );
}
else if ( itksys::SystemTools::Strucmp( atts[i], "ConvergedPercentageToStop" ) == 0 )
{
std::istringstream iss( atts[i+1] );
double stoppercent = 0;
iss >> stoppercent;
opt->SetPercentageParticlesConverged( stoppercent );
}
}
}
void ParticleSwarmOptimizerSAXReader::ProcessBoundAttributes( const char** atts, std::vector<double>& bound )
{
// go over all the attribute-value pairs
for ( size_t i = 0; atts[i] != 0; i += 2 )
{
if ( itksys::SystemTools::Strucmp( atts[i], "value" ) == 0 )
{
bound.clear();
//
std::istringstream iss( atts[i+1] );
while ( iss.good() )
{
double value = 0;
iss >> value;
if ( !iss.fail() && !iss.bad() )
{
bound.push_back( value );
}
}
} // end if
} // end for
}
const char* ParticleSwarmOptimizerSAXReader::GetAttribute( const char** atts, const char* key )
{
// go over all the attribute-value pairs
for ( size_t i = 0; atts[i] != 0; i += 2 )
{
if ( itksys::SystemTools::Strucmp( atts[i], key ) == 0 )
{
return atts[i+1];
}
}
return 0;
}
bool ParticleSwarmOptimizerSAXReader::ContextIs( const char* test ) const
{
std::string s = "";
for ( size_t i = 0; i < this->m_CurrentTags.size(); i++ )
{
s += "/" + std::string(this->m_CurrentTags[i]);
}
if ( s.size() == 0 )
{
s = "/";
}
return ( s == std::string(test) );
}
} // namespace itk