mitk: mitkRigidRegistrationPreset.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date: 2007-12-11 14:46:19 +0100 (Di, 11 Dez 2007) $
00006 Version:   $Revision: 13129 $
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkRigidRegistrationPreset.h"
00019 #include "mitkStandardFileLocations.h"
00020 #include "mitkMetricParameters.h"
00021 #include "mitkOptimizerParameters.h"
00022 #include "mitkTransformParameters.h"
00023 
00024 namespace mitk {
00025 
00026   RigidRegistrationPreset::RigidRegistrationPreset()
00027   {
00028     m_Name = "";
00029     m_XmlFileName = "mitkRigidRegistrationPresets.xml";
00030   }
00031 
00032   RigidRegistrationPreset::~RigidRegistrationPreset()
00033   {
00034   }
00035 
00036   bool RigidRegistrationPreset::LoadPreset()
00037   {
00038     std::string location1 = MITK_ROOT;
00039     std::string location2 = "/QFunctionalities/QmitkRigidRegistration";
00040     std::string location = location1 + location2;
00041     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch(location.c_str(), true);
00042     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch("/bin", true);
00043     std::string xmlFileName = mitk::StandardFileLocations::GetInstance()->FindFile("mitkRigidRegistrationPresets.xml", "Config");
00044 
00045     if (!xmlFileName.empty())
00046     {
00047       m_XmlFileName = xmlFileName;
00048       return LoadPreset(m_XmlFileName);
00049     }
00050     else
00051       return false;
00052   }
00053 
00054   bool RigidRegistrationPreset::LoadPreset(std::string fileName)
00055   {
00056     if ( fileName.empty() )
00057       return false;
00058 
00059     vtkXMLParser::SetFileName( fileName.c_str() );
00060     m_XmlFileName = fileName;
00061 
00062     if ( !vtkXMLParser::Parse() )
00063     {
00064   #ifdef INTERDEBUG
00065       MITK_INFO<<"RigidRegistrationPreset::LoadPreset xml file cannot parse!"<<std::endl;
00066   #endif
00067     }
00068 
00069     return true;
00070 
00071   }
00072 
00073   void  RigidRegistrationPreset::StartElement (const char *elementName, const char **atts)
00074   {
00075     std::string elementNameString = elementName;
00076     if ( elementNameString == "preset" )
00077     {
00078       m_Name = ReadXMLStringAttribut( "NAME", atts );
00079     }
00080     else if (elementNameString == "transform")
00081     {
00082       itk::Array<double> transformValues;
00083       transformValues.SetSize(25);
00084       transformValues.fill(0);
00085       std::string transform = ReadXMLStringAttribut( "TRANSFORM", atts );
00086       double trans = atof(transform.c_str());
00087       transformValues[0] = trans;
00088       transformValues = this->loadTransformValues(transformValues, trans, atts);
00089       m_TransformValues[m_Name] = transformValues;
00090     }
00091     else if (elementNameString == "metric")
00092     {
00093       itk::Array<double> metricValues;
00094       metricValues.SetSize(25);
00095       metricValues.fill(0);
00096       std::string metric = ReadXMLStringAttribut( "METRIC", atts );
00097       double met = atof(metric.c_str());
00098       metricValues[0] = met;
00099       metricValues = this->loadMetricValues(metricValues, met, atts);
00100       m_MetricValues[m_Name] = metricValues;
00101     }
00102     else if (elementNameString == "optimizer")
00103     {
00104       itk::Array<double> optimizerValues;
00105       optimizerValues.SetSize(25);
00106       optimizerValues.fill(0);
00107       std::string optimizer = ReadXMLStringAttribut( "OPTIMIZER", atts );
00108       double opt = atof(optimizer.c_str());
00109       optimizerValues[0] = opt;
00110       optimizerValues = this->loadOptimizerValues(optimizerValues, opt, atts);
00111       m_OptimizerValues[m_Name] = optimizerValues;
00112     }
00113     else if (elementNameString == "interpolator")
00114     {
00115       itk::Array<double> interpolatorValues;
00116       interpolatorValues.SetSize(25);
00117       interpolatorValues.fill(0);
00118       std::string interpolator = ReadXMLStringAttribut( "INTERPOLATOR", atts );
00119       double inter = atof(interpolator.c_str());
00120       interpolatorValues[0] = inter;
00121       interpolatorValues = this->loadInterpolatorValues(interpolatorValues/*, inter, atts*/);
00122       m_InterpolatorValues[m_Name] = interpolatorValues;
00123     }
00124   }
00125 
00126   std::string RigidRegistrationPreset::ReadXMLStringAttribut( std::string name, const char** atts )
00127   {
00128     if(atts)
00129     {
00130       const char** attsIter = atts;
00131 
00132       while(*attsIter)
00133       {
00134         if ( name == *attsIter )
00135         {
00136           attsIter++;
00137           return *attsIter;
00138         }
00139         attsIter++;
00140         attsIter++;
00141       }
00142     }
00143 
00144     return std::string();
00145   }
00146 
00147   itk::Array<double> RigidRegistrationPreset::getTransformValues(std::string name)
00148   {
00149     return m_TransformValues[name];
00150   }
00151 
00152   itk::Array<double> RigidRegistrationPreset::getMetricValues(std::string name)
00153   {
00154     return m_MetricValues[name];
00155   }
00156 
00157   itk::Array<double> RigidRegistrationPreset::getOptimizerValues(std::string name)
00158   {
00159     return m_OptimizerValues[name];
00160   }
00161 
00162   itk::Array<double> RigidRegistrationPreset::getInterpolatorValues(std::string name)
00163   {
00164     return m_InterpolatorValues[name];
00165   }
00166 
00167   std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getTransformValuesPresets()
00168   {
00169     return m_TransformValues;
00170   }
00171 
00172   std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getMetricValuesPresets()
00173   {
00174     return m_MetricValues;
00175   }
00176 
00177   std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getOptimizerValuesPresets()
00178   {
00179     return m_OptimizerValues;
00180   }
00181 
00182   std::map<std::string, itk::Array<double> >& RigidRegistrationPreset::getInterpolatorValuesPresets()
00183   {
00184     return m_InterpolatorValues;
00185   }
00186 
00187   bool RigidRegistrationPreset::save()
00188   {
00189     //XMLWriter writer(m_XmlFileName.c_str());
00190     //return saveXML(writer);
00191     return false;
00192   }
00193 
00194   //bool RigidRegistrationPreset::saveXML(mitk::XMLWriter& xmlWriter)
00195   //{
00196   //  xmlWriter.BeginNode("mitkRigidRegistrationPresets");
00197   //  for( std::map<std::string, itk::Array<double> >::iterator iter = m_TransformValues.begin(); iter != m_TransformValues.end(); iter++ ) {
00198   //    std::string item = ((*iter).first.c_str());
00199   //    xmlWriter.BeginNode("preset");
00200   //    xmlWriter.WriteProperty("NAME", item);
00201   //    xmlWriter.BeginNode("transform");
00202   //    this->saveTransformValues(xmlWriter, item);
00203   //    xmlWriter.EndNode();
00204   //    xmlWriter.BeginNode("metric");
00205   //    this->saveMetricValues(xmlWriter, item);
00206   //    xmlWriter.EndNode();
00207   //    xmlWriter.BeginNode("optimizer");
00208   //    this->saveOptimizerValues(xmlWriter, item);
00209   //    xmlWriter.EndNode();
00210   //    xmlWriter.BeginNode("interpolator");
00211   //    this->saveInterpolatorValues(xmlWriter, item);
00212   //    xmlWriter.EndNode();
00213   //    xmlWriter.EndNode();
00214   //  }
00215   //  xmlWriter.EndNode();
00216   //  return true;
00217   //}
00218 
00219   bool RigidRegistrationPreset::newPresets(std::map<std::string, itk::Array<double> > newTransformValues, std::map<std::string, itk::Array<double> > newMetricValues,
00220     std::map<std::string, itk::Array<double> > newOptimizerValues, std::map<std::string, itk::Array<double> > newInterpolatorValues, std::string fileName)
00221   {
00222     if ( !fileName.empty() )
00223     {
00224       m_XmlFileName = fileName;
00225     }
00226     m_TransformValues = newTransformValues;
00227     m_MetricValues = newMetricValues;
00228     m_OptimizerValues = newOptimizerValues;
00229     m_InterpolatorValues = newInterpolatorValues;
00230     return save();
00231   }
00232 
00233   //void RigidRegistrationPreset::saveTransformValues(mitk::XMLWriter& xmlWriter, std::string item)
00234   //{
00235   //  itk::Array<double> transformValues = m_TransformValues[item];
00236   //  double transform = transformValues[0];
00237   //  xmlWriter.WriteProperty("TRANSFORM", transformValues[0]);
00238   //  if (transform == mitk::TransformParameters::TRANSLATIONTRANSFORM || transform == mitk::TransformParameters::SCALETRANSFORM || 
00239   //        transform == mitk::TransformParameters::SCALELOGARITHMICTRANSFORM || transform == mitk::TransformParameters::VERSORTRANSFORM ||
00240   //        transform == mitk::TransformParameters::RIGID2DTRANSFORM || transform == mitk::TransformParameters::EULER2DTRANSFORM)
00241   //  {
00242   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00243   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00244   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00245   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00246   //  }
00247   //  else if (transform == mitk::TransformParameters::AFFINETRANSFORM || transform == mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
00248   //  {
00249   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00250   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00251   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00252   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00253   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00254   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00255   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00256   //    xmlWriter.WriteProperty("SCALE7", transformValues[8]);
00257   //    xmlWriter.WriteProperty("SCALE8", transformValues[9]);
00258   //    xmlWriter.WriteProperty("SCALE9", transformValues[10]);
00259   //    xmlWriter.WriteProperty("SCALE10", transformValues[11]);
00260   //    xmlWriter.WriteProperty("SCALE11", transformValues[12]);
00261   //    xmlWriter.WriteProperty("SCALE12", transformValues[13]);
00262   //   /* xmlWriter.WriteProperty("SCALE13", transformValues[14]);
00263   //    xmlWriter.WriteProperty("SCALE14", transformValues[15]);
00264   //    xmlWriter.WriteProperty("SCALE15", transformValues[16]);
00265   //    xmlWriter.WriteProperty("SCALE16", transformValues[17]);*/
00266   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[14]);
00267   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[15]);
00268   //  }
00269   //  else if (transform == mitk::TransformParameters::RIGID3DTRANSFORM)
00270   //  {
00271   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00272   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00273   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00274   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00275   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00276   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00277   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00278   //    xmlWriter.WriteProperty("SCALE7", transformValues[8]);
00279   //    xmlWriter.WriteProperty("SCALE8", transformValues[9]);
00280   //    xmlWriter.WriteProperty("SCALE9", transformValues[10]);
00281   //    xmlWriter.WriteProperty("SCALE10", transformValues[11]);
00282   //    xmlWriter.WriteProperty("SCALE11", transformValues[12]);
00283   //    xmlWriter.WriteProperty("SCALE12", transformValues[13]);
00284   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[14]);
00285   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[15]);
00286   //  }
00287   //  else if (transform == mitk::TransformParameters::EULER3DTRANSFORM || transform == mitk::TransformParameters::CENTEREDEULER3DTRANSFORM
00288   //        || transform == mitk::TransformParameters::VERSORRIGID3DTRANSFORM)
00289   //  {
00290   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00291   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00292   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00293   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00294   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00295   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00296   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00297   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
00298   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
00299   //  }
00300   //  else if (transform == mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM || transform == mitk::TransformParameters::SIMILARITY3DTRANSFORM)
00301   //  {
00302   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00303   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00304   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00305   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00306   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00307   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00308   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00309   //    xmlWriter.WriteProperty("SCALE7", transformValues[8]);
00310   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[9]);
00311   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[10]);
00312   //  }
00313   //  else if (transform == mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
00314   //  {
00315   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00316   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00317   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00318   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00319   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00320   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00321   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00322   //    xmlWriter.WriteProperty("SCALE7", transformValues[8]);
00323   //    xmlWriter.WriteProperty("SCALE8", transformValues[9]);
00324   //    xmlWriter.WriteProperty("SCALE9", transformValues[10]);
00325   //    xmlWriter.WriteProperty("SCALE10", transformValues[11]);
00326   //    xmlWriter.WriteProperty("SCALE11", transformValues[12]);
00327   //    xmlWriter.WriteProperty("SCALE12", transformValues[13]);
00328   //    xmlWriter.WriteProperty("SCALE13", transformValues[14]);
00329   //    xmlWriter.WriteProperty("SCALE14", transformValues[15]);
00330   //    xmlWriter.WriteProperty("SCALE15", transformValues[16]);
00331   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[17]);
00332   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[18]);
00333   //  }
00334   //  else if (transform == mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM)
00335   //  {
00336   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00337   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00338   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00339   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00340   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00341   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00342   //    xmlWriter.WriteProperty("ANGLE", transformValues[7]);
00343   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
00344   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
00345   //  }
00346   //  else if (transform == mitk::TransformParameters::SIMILARITY2DTRANSFORM)
00347   //  {
00348   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00349   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00350   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00351   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00352   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00353   //    xmlWriter.WriteProperty("SCALE", transformValues[6]);
00354   //    xmlWriter.WriteProperty("ANGLE", transformValues[7]);
00355   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[8]);
00356   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[9]);
00357   //  }
00358   //  else if (transform == mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
00359   //  {
00360   //    xmlWriter.WriteProperty("USESCALES", transformValues[1]);
00361   //    xmlWriter.WriteProperty("SCALE1", transformValues[2]);
00362   //    xmlWriter.WriteProperty("SCALE2", transformValues[3]);
00363   //    xmlWriter.WriteProperty("SCALE3", transformValues[4]);
00364   //    xmlWriter.WriteProperty("SCALE4", transformValues[5]);
00365   //    xmlWriter.WriteProperty("SCALE5", transformValues[6]);
00366   //    xmlWriter.WriteProperty("SCALE6", transformValues[7]);
00367   //    xmlWriter.WriteProperty("SCALE", transformValues[8]);
00368   //    xmlWriter.WriteProperty("ANGLE", transformValues[9]);
00369   //    xmlWriter.WriteProperty("USEINITIALIZER", transformValues[10]);
00370   //    xmlWriter.WriteProperty("USEMOMENTS", transformValues[11]);
00371   //  }
00372   //}
00373 
00374   //void RigidRegistrationPreset::saveMetricValues(mitk::XMLWriter& xmlWriter, std::string item)
00375   //{
00376   //  itk::Array<double> metricValues = m_MetricValues[item];
00377   //  double metric = metricValues[0];
00378   //  xmlWriter.WriteProperty("METRIC", metricValues[0]);
00379   //  xmlWriter.WriteProperty("COMPUTEGRADIENT", metricValues[1]);
00380   //  if (metric == mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC
00381   //      || metric == mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC
00382   //      || metric == mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC)
00383   //  {
00384   //  }
00385   //  else if (metric == mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC
00386   //    || metric == mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC
00387   //    || metric == mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC
00388   //    || metric == mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
00389   //    || metric == mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC)
00390   //  {
00391   //    xmlWriter.WriteProperty("HISTOGRAMBINS", metricValues[2]);
00392   //  }
00393   //  else if (metric == mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC)
00394   //  {
00395   //    xmlWriter.WriteProperty("USESAMPLING", metricValues[2]);
00396   //    xmlWriter.WriteProperty("SPATIALSAMPLES", metricValues[3]);
00397   //    xmlWriter.WriteProperty("HISTOGRAMBINS", metricValues[4]);
00398   //  }
00399   //  else if (metric == mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC)
00400   //  {
00401   //    xmlWriter.WriteProperty("LAMBDA", metricValues[2]);
00402   //  }
00403   //  else if (metric == mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC)
00404   //  {
00405   //    xmlWriter.WriteProperty("SPATIALSAMPLES", metricValues[2]);
00406   //    xmlWriter.WriteProperty("FIXEDSTANDARDDEVIATION", metricValues[3]);
00407   //    xmlWriter.WriteProperty("MOVINGSTANDARDDEVIATION", metricValues[4]);
00408   //    xmlWriter.WriteProperty("USENORMALIZERANDSMOOTHER", metricValues[5]);
00409   //    xmlWriter.WriteProperty("FIXEDSMOOTHERVARIANCE", metricValues[6]);
00410   //    xmlWriter.WriteProperty("MOVINGSMOOTHERVARIANCE", metricValues[7]);
00411   //  }
00412   //}
00413 
00414   //void RigidRegistrationPreset::saveOptimizerValues(mitk::XMLWriter& xmlWriter, std::string item)
00415   //{
00416   //  itk::Array<double> optimizerValues = m_OptimizerValues[item];
00417   //  double optimizer = optimizerValues[0];
00418   //  xmlWriter.WriteProperty("OPTIMIZER", optimizerValues[0]);
00419   //  xmlWriter.WriteProperty("MAXIMIZE", optimizerValues[1]);
00420   //  if (optimizer == mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER)
00421   //  {
00422   //    xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[2]);
00423   //    xmlWriter.WriteProperty("NUMBEROFSTEPS", optimizerValues[3]);
00424   //  }
00425   //  else if (optimizer == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER
00426   //          || optimizer == mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
00427   //  {
00428   //    xmlWriter.WriteProperty("LEARNINGRATE", optimizerValues[2]);
00429   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[3]);
00430   //  }
00431   //  else if (optimizer == mitk::OptimizerParameters::LBFGSBOPTIMIZER)
00432   //  {
00433   //  }
00434   //  else if (optimizer == mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
00435   //  {
00436   //    xmlWriter.WriteProperty("SHRINKFACTOR", optimizerValues[2]);
00437   //    xmlWriter.WriteProperty("GROWTHFACTOR", optimizerValues[3]);
00438   //    xmlWriter.WriteProperty("EPSILON", optimizerValues[4]);
00439   //    xmlWriter.WriteProperty("INITIALRADIUS", optimizerValues[5]);
00440   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[6]);
00441   //  }
00442   //  else if (optimizer == mitk::OptimizerParameters::POWELLOPTIMIZER)
00443   //  {
00444   //    xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[2]);
00445   //    xmlWriter.WriteProperty("STEPTOLERANCE", optimizerValues[3]);
00446   //    xmlWriter.WriteProperty("VALUETOLERANCE", optimizerValues[4]);
00447   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
00448   //  }
00449   //  else if (optimizer == mitk::OptimizerParameters::FRPROPTIMIZER)
00450   //  {
00451   //    xmlWriter.WriteProperty("USEFLETCHREEVES", optimizerValues[2]);
00452   //    xmlWriter.WriteProperty("STEPLENGTH", optimizerValues[3]);
00453   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[4]);
00454   //  }
00455   //  else if (optimizer == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
00456   //  {
00457   //    xmlWriter.WriteProperty("GRADIENTMAGNITUDETOLERANCE", optimizerValues[2]);
00458   //    xmlWriter.WriteProperty("MINSTEPLENGTH", optimizerValues[3]);
00459   //    xmlWriter.WriteProperty("MAXSTEPLENGTH", optimizerValues[4]);
00460   //    xmlWriter.WriteProperty("RELAXATIONFACTOR", optimizerValues[5]);
00461   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[6]);
00462   //  }
00463   //  else if (optimizer == mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER || optimizer == mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
00464   //  {
00465   //    xmlWriter.WriteProperty("GRADIENTMAGNITUDETOLERANCE", optimizerValues[2]);
00466   //    xmlWriter.WriteProperty("MINSTEPLENGTH", optimizerValues[3]);
00467   //    xmlWriter.WriteProperty("MAXSTEPLENGTH", optimizerValues[4]);
00468   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
00469   //  }
00470   //  else if (optimizer == mitk::OptimizerParameters::AMOEBAOPTIMIZER)
00471   //  {
00472   //    xmlWriter.WriteProperty("SIMPLEXDELTA1", optimizerValues[2]);
00473   //    xmlWriter.WriteProperty("SIMPLEXDELTA2", optimizerValues[3]);
00474   //    xmlWriter.WriteProperty("SIMPLEXDELTA3", optimizerValues[4]);
00475   //    xmlWriter.WriteProperty("SIMPLEXDELTA4", optimizerValues[5]);
00476   //    xmlWriter.WriteProperty("SIMPLEXDELTA5", optimizerValues[6]);
00477   //    xmlWriter.WriteProperty("SIMPLEXDELTA6", optimizerValues[7]);
00478   //    xmlWriter.WriteProperty("SIMPLEXDELTA7", optimizerValues[8]);
00479   //    xmlWriter.WriteProperty("SIMPLEXDELTA8", optimizerValues[9]);
00480   //    xmlWriter.WriteProperty("SIMPLEXDELTA9", optimizerValues[10]);
00481   //    xmlWriter.WriteProperty("SIMPLEXDELTA10", optimizerValues[11]);
00482   //    xmlWriter.WriteProperty("SIMPLEXDELTA11", optimizerValues[12]);
00483   //    xmlWriter.WriteProperty("SIMPLEXDELTA12", optimizerValues[13]);
00484   //    xmlWriter.WriteProperty("SIMPLEXDELTA13", optimizerValues[14]);
00485   //    xmlWriter.WriteProperty("SIMPLEXDELTA14", optimizerValues[15]);
00486   //    xmlWriter.WriteProperty("SIMPLEXDELTA15", optimizerValues[16]);
00487   //    xmlWriter.WriteProperty("SIMPLEXDELTA16", optimizerValues[17]);
00488   //    xmlWriter.WriteProperty("PARAMETERSCONVERGENCETOLERANCE", optimizerValues[18]);
00489   //    xmlWriter.WriteProperty("FUNCTIONCONVERGENCETOLERANCE", optimizerValues[19]);
00490   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[20]);
00491   //  }
00492   //  else if (optimizer == mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
00493   //  {
00494   //  }
00495   //  else if (optimizer == mitk::OptimizerParameters::LBFGSOPTIMIZER)
00496   //  {
00497   //    xmlWriter.WriteProperty("GRADIENTCONVERGENCETOLERANCE", optimizerValues[2]);
00498   //    xmlWriter.WriteProperty("LINESEARCHACCURACY", optimizerValues[3]);
00499   //    xmlWriter.WriteProperty("DEFAULTSTEPLENGTH", optimizerValues[4]);
00500   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[5]);
00501   //    xmlWriter.WriteProperty("USETRACE", optimizerValues[6]);
00502   //  }
00503   //  else if (optimizer == mitk::OptimizerParameters::SPSAOPTIMIZER)
00504   //  {
00505   //    xmlWriter.WriteProperty("a", optimizerValues[2]);
00506   //    xmlWriter.WriteProperty("A", optimizerValues[3]);
00507   //    xmlWriter.WriteProperty("ALPHA", optimizerValues[4]);
00508   //    xmlWriter.WriteProperty("c", optimizerValues[5]);
00509   //    xmlWriter.WriteProperty("GAMMA", optimizerValues[6]);
00510   //    xmlWriter.WriteProperty("TOLERANCE", optimizerValues[7]);
00511   //    xmlWriter.WriteProperty("STATEOFCONVERGENCEDECAYRATE", optimizerValues[8]);
00512   //    xmlWriter.WriteProperty("MINNUMBERITERATIONS", optimizerValues[9]);
00513   //    xmlWriter.WriteProperty("NUMBERPERTURBATIONS", optimizerValues[10]);
00514   //    xmlWriter.WriteProperty("NUMBERITERATIONS", optimizerValues[11]);
00515   //  }
00516   //}
00517 
00518   //void RigidRegistrationPreset::saveInterpolatorValues(mitk::XMLWriter& xmlWriter, std::string item)
00519   //{
00520   //  itk::Array<double> interpolatorValues = m_InterpolatorValues[item];
00521   //  xmlWriter.WriteProperty("INTERPOLATOR", interpolatorValues[0]);
00522   //}
00523 
00524   itk::Array<double> RigidRegistrationPreset::loadTransformValues(itk::Array<double> transformValues, double transform, const char **atts)
00525   {
00526     if (transform == mitk::TransformParameters::TRANSLATIONTRANSFORM || transform == mitk::TransformParameters::SCALETRANSFORM || 
00527           transform == mitk::TransformParameters::SCALELOGARITHMICTRANSFORM || transform == mitk::TransformParameters::VERSORTRANSFORM ||
00528           transform == mitk::TransformParameters::RIGID2DTRANSFORM || transform == mitk::TransformParameters::EULER2DTRANSFORM)
00529     {
00530       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00531       double useSca = atof(useScales.c_str());
00532       transformValues[1] = useSca;
00533       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00534       double sca1 = atof(scale1.c_str());
00535       transformValues[2] = sca1;
00536       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00537       double sca2 = atof(scale2.c_str());
00538       transformValues[3] = sca2;
00539       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00540       double sca3 = atof(scale3.c_str());
00541       transformValues[4] = sca3;
00542     }
00543     else if (transform == mitk::TransformParameters::AFFINETRANSFORM || transform == mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
00544     {
00545       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00546       double useSca = atof(useScales.c_str());
00547       transformValues[1] = useSca;
00548       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00549       double sca1 = atof(scale1.c_str());
00550       transformValues[2] = sca1;
00551       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00552       double sca2 = atof(scale2.c_str());
00553       transformValues[3] = sca2;
00554       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00555       double sca3 = atof(scale3.c_str());
00556       transformValues[4] = sca3;
00557       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00558       double sca4 = atof(scale4.c_str());
00559       transformValues[5] = sca4;
00560       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00561       double sca5 = atof(scale5.c_str());
00562       transformValues[6] = sca5;
00563       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00564       double sca6 = atof(scale6.c_str());
00565       transformValues[7] = sca6;
00566       std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
00567       double sca7 = atof(scale7.c_str());
00568       transformValues[8] = sca7;
00569       std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
00570       double sca8 = atof(scale8.c_str());
00571       transformValues[9] = sca8;
00572       std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
00573       double sca9 = atof(scale9.c_str());
00574       transformValues[10] = sca9;
00575       std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
00576       double sca10 = atof(scale10.c_str());
00577       transformValues[11] = sca10;
00578       std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
00579       double sca11 = atof(scale11.c_str());
00580       transformValues[12] = sca11;
00581       std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
00582       double sca12 = atof(scale12.c_str());
00583       transformValues[13] = sca12;
00584 
00585       /*
00586       std::string scale13 = ReadXMLStringAttribut( "SCALE13", atts );
00587       double sca13 = atof(scale13.c_str());
00588       transformValues[14] = sca13;
00589       std::string scale14 = ReadXMLStringAttribut( "SCALE14", atts );
00590       double sca14 = atof(scale14.c_str());
00591       transformValues[15] = sca14;
00592       std::string scale15 = ReadXMLStringAttribut( "SCALE15", atts );
00593       double sca15 = atof(scale15.c_str());
00594       transformValues[16] = sca15;
00595       std::string scale16 = ReadXMLStringAttribut( "SCALE16", atts );
00596       double sca16 = atof(scale16.c_str());
00597       transformValues[17] = sca16;
00598       */
00599 
00600       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00601       double useIni = atof(useInitializer.c_str());
00602       transformValues[14] = useIni;
00603       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00604       double useMo = atof(useMoments.c_str());
00605       transformValues[15] = useMo;
00606     }
00607     else if (transform == mitk::TransformParameters::RIGID3DTRANSFORM)
00608     {
00609       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00610       double useSca = atof(useScales.c_str());
00611       transformValues[1] = useSca;
00612       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00613       double sca1 = atof(scale1.c_str());
00614       transformValues[2] = sca1;
00615       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00616       double sca2 = atof(scale2.c_str());
00617       transformValues[3] = sca2;
00618       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00619       double sca3 = atof(scale3.c_str());
00620       transformValues[4] = sca3;
00621       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00622       double sca4 = atof(scale4.c_str());
00623       transformValues[5] = sca4;
00624       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00625       double sca5 = atof(scale5.c_str());
00626       transformValues[6] = sca5;
00627       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00628       double sca6 = atof(scale6.c_str());
00629       transformValues[7] = sca6;
00630       std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
00631       double sca7 = atof(scale7.c_str());
00632       transformValues[8] = sca7;
00633       std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
00634       double sca8 = atof(scale8.c_str());
00635       transformValues[9] = sca8;
00636       std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
00637       double sca9 = atof(scale9.c_str());
00638       transformValues[10] = sca9;
00639       std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
00640       double sca10 = atof(scale10.c_str());
00641       transformValues[11] = sca10;
00642       std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
00643       double sca11 = atof(scale11.c_str());
00644       transformValues[12] = sca11;
00645       std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
00646       double sca12 = atof(scale12.c_str());
00647       transformValues[13] = sca12;
00648       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00649       double useIni = atof(useInitializer.c_str());
00650       transformValues[14] = useIni;
00651       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00652       double useMo = atof(useMoments.c_str());
00653       transformValues[15] = useMo;
00654     }
00655     else if (transform == mitk::TransformParameters::EULER3DTRANSFORM || transform == mitk::TransformParameters::CENTEREDEULER3DTRANSFORM
00656           || transform == mitk::TransformParameters::VERSORRIGID3DTRANSFORM)
00657     {
00658       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00659       double useSca = atof(useScales.c_str());
00660       transformValues[1] = useSca;
00661       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00662       double sca1 = atof(scale1.c_str());
00663       transformValues[2] = sca1;
00664       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00665       double sca2 = atof(scale2.c_str());
00666       transformValues[3] = sca2;
00667       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00668       double sca3 = atof(scale3.c_str());
00669       transformValues[4] = sca3;
00670       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00671       double sca4 = atof(scale4.c_str());
00672       transformValues[5] = sca4;
00673       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00674       double sca5 = atof(scale5.c_str());
00675       transformValues[6] = sca5;
00676       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00677       double sca6 = atof(scale6.c_str());
00678       transformValues[7] = sca6;
00679       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00680       double useIni = atof(useInitializer.c_str());
00681       transformValues[8] = useIni;
00682       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00683       double useMo = atof(useMoments.c_str());
00684       transformValues[9] = useMo;
00685     }
00686     else if (transform == mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM || transform == mitk::TransformParameters::SIMILARITY3DTRANSFORM)
00687     {
00688       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00689       double useSca = atof(useScales.c_str());
00690       transformValues[1] = useSca;
00691       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00692       double sca1 = atof(scale1.c_str());
00693       transformValues[2] = sca1;
00694       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00695       double sca2 = atof(scale2.c_str());
00696       transformValues[3] = sca2;
00697       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00698       double sca3 = atof(scale3.c_str());
00699       transformValues[4] = sca3;
00700       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00701       double sca4 = atof(scale4.c_str());
00702       transformValues[5] = sca4;
00703       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00704       double sca5 = atof(scale5.c_str());
00705       transformValues[6] = sca5;
00706       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00707       double sca6 = atof(scale6.c_str());
00708       transformValues[7] = sca6;
00709       std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
00710       double sca7 = atof(scale7.c_str());
00711       transformValues[8] = sca7;
00712       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00713       double useIni = atof(useInitializer.c_str());
00714       transformValues[9] = useIni;
00715       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00716       double useMo = atof(useMoments.c_str());
00717       transformValues[10] = useMo;
00718     }
00719     else if (transform == mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
00720     {
00721       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00722       double useSca = atof(useScales.c_str());
00723       transformValues[1] = useSca;
00724       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00725       double sca1 = atof(scale1.c_str());
00726       transformValues[2] = sca1;
00727       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00728       double sca2 = atof(scale2.c_str());
00729       transformValues[3] = sca2;
00730       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00731       double sca3 = atof(scale3.c_str());
00732       transformValues[4] = sca3;
00733       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00734       double sca4 = atof(scale4.c_str());
00735       transformValues[5] = sca4;
00736       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00737       double sca5 = atof(scale5.c_str());
00738       transformValues[6] = sca5;
00739       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00740       double sca6 = atof(scale6.c_str());
00741       transformValues[7] = sca6;
00742       std::string scale7 = ReadXMLStringAttribut( "SCALE7", atts );
00743       double sca7 = atof(scale7.c_str());
00744       transformValues[8] = sca7;
00745       std::string scale8 = ReadXMLStringAttribut( "SCALE8", atts );
00746       double sca8 = atof(scale8.c_str());
00747       transformValues[9] = sca8;
00748       std::string scale9 = ReadXMLStringAttribut( "SCALE9", atts );
00749       double sca9 = atof(scale9.c_str());
00750       transformValues[10] = sca9;
00751       std::string scale10 = ReadXMLStringAttribut( "SCALE10", atts );
00752       double sca10 = atof(scale10.c_str());
00753       transformValues[11] = sca10;
00754       std::string scale11 = ReadXMLStringAttribut( "SCALE11", atts );
00755       double sca11 = atof(scale11.c_str());
00756       transformValues[12] = sca11;
00757       std::string scale12 = ReadXMLStringAttribut( "SCALE12", atts );
00758       double sca12 = atof(scale12.c_str());
00759       transformValues[13] = sca12;
00760       std::string scale13 = ReadXMLStringAttribut( "SCALE13", atts );
00761       double sca13 = atof(scale13.c_str());
00762       transformValues[14] = sca13;
00763       std::string scale14 = ReadXMLStringAttribut( "SCALE14", atts );
00764       double sca14 = atof(scale14.c_str());
00765       transformValues[15] = sca14;
00766       std::string scale15 = ReadXMLStringAttribut( "SCALE15", atts );
00767       double sca15 = atof(scale15.c_str());
00768       transformValues[16] = sca15;
00769       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00770       double useIni = atof(useInitializer.c_str());
00771       transformValues[17] = useIni;
00772       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00773       double useMo = atof(useMoments.c_str());
00774       transformValues[18] = useMo;
00775     }
00776     else if (transform == mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM)
00777     {
00778       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00779       double useSca = atof(useScales.c_str());
00780       transformValues[1] = useSca;
00781       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00782       double sca1 = atof(scale1.c_str());
00783       transformValues[2] = sca1;
00784       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00785       double sca2 = atof(scale2.c_str());
00786       transformValues[3] = sca2;
00787       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00788       double sca3 = atof(scale3.c_str());
00789       transformValues[4] = sca3;
00790       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00791       double sca4 = atof(scale4.c_str());
00792       transformValues[5] = sca4;
00793       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00794       double sca5 = atof(scale5.c_str());
00795       transformValues[6] = sca5;
00796       std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
00797       double ang = atof(angle.c_str());
00798       transformValues[7] = ang;
00799       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00800       double useIni = atof(useInitializer.c_str());
00801       transformValues[8] = useIni;
00802       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00803       double useMo = atof(useMoments.c_str());
00804       transformValues[9] = useMo;
00805     }
00806     else if (transform == mitk::TransformParameters::SIMILARITY2DTRANSFORM)
00807     {
00808       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00809       double useSca = atof(useScales.c_str());
00810       transformValues[1] = useSca;
00811       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00812       double sca1 = atof(scale1.c_str());
00813       transformValues[2] = sca1;
00814       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00815       double sca2 = atof(scale2.c_str());
00816       transformValues[3] = sca2;
00817       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00818       double sca3 = atof(scale3.c_str());
00819       transformValues[4] = sca3;
00820       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00821       double sca4 = atof(scale4.c_str());
00822       transformValues[5] = sca4;
00823       std::string scale = ReadXMLStringAttribut( "SCALE", atts );
00824       double sca = atof(scale.c_str());
00825       transformValues[6] = sca;
00826       std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
00827       double ang = atof(angle.c_str());
00828       transformValues[7] = ang;
00829       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00830       double useIni = atof(useInitializer.c_str());
00831       transformValues[8] = useIni;
00832       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00833       double useMo = atof(useMoments.c_str());
00834       transformValues[9] = useMo;
00835     }
00836     else if (transform == mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
00837     {
00838       std::string useScales = ReadXMLStringAttribut( "USESCALES", atts );
00839       double useSca = atof(useScales.c_str());
00840       transformValues[1] = useSca;
00841       std::string scale1 = ReadXMLStringAttribut( "SCALE1", atts );
00842       double sca1 = atof(scale1.c_str());
00843       transformValues[2] = sca1;
00844       std::string scale2 = ReadXMLStringAttribut( "SCALE2", atts );
00845       double sca2 = atof(scale2.c_str());
00846       transformValues[3] = sca2;
00847       std::string scale3 = ReadXMLStringAttribut( "SCALE3", atts );
00848       double sca3 = atof(scale3.c_str());
00849       transformValues[4] = sca3;
00850       std::string scale4 = ReadXMLStringAttribut( "SCALE4", atts );
00851       double sca4 = atof(scale4.c_str());
00852       transformValues[5] = sca4;
00853       std::string scale5 = ReadXMLStringAttribut( "SCALE5", atts );
00854       double sca5 = atof(scale5.c_str());
00855       transformValues[6] = sca5;
00856       std::string scale6 = ReadXMLStringAttribut( "SCALE6", atts );
00857       double sca6 = atof(scale6.c_str());
00858       transformValues[7] = sca6;
00859       std::string scale = ReadXMLStringAttribut( "SCALE", atts );
00860       double sca = atof(scale.c_str());
00861       transformValues[8] = sca;
00862       std::string angle = ReadXMLStringAttribut( "ANGLE", atts );
00863       double ang = atof(angle.c_str());
00864       transformValues[9] = ang;
00865       std::string useInitializer = ReadXMLStringAttribut( "USEINITIALIZER", atts );
00866       double useIni = atof(useInitializer.c_str());
00867       transformValues[10] = useIni;
00868       std::string useMoments = ReadXMLStringAttribut( "USEMOMENTS", atts );
00869       double useMo = atof(useMoments.c_str());
00870       transformValues[11] = useMo;
00871     }
00872     return transformValues;
00873   }
00874 
00875   itk::Array<double> RigidRegistrationPreset::loadMetricValues(itk::Array<double> metricValues, double metric, const char **atts)
00876   {
00877     std::string computeGradient = ReadXMLStringAttribut( "COMPUTEGRADIENT", atts );
00878     double compGra = atof(computeGradient.c_str());
00879     metricValues[1] = compGra;
00880     if (metric == mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC
00881         || metric == mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC || metric == mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC
00882         || metric == mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC)
00883     {
00884     }
00885     else if (metric == mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC
00886       || metric == mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC
00887       || metric == mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC
00888       || metric == mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
00889       || metric == mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC)
00890     {
00891       std::string histogramBins = ReadXMLStringAttribut( "HISTOGRAMBINS", atts );
00892       double histBins = atof(histogramBins.c_str());
00893       metricValues[2] = histBins;
00894     }
00895     else if (metric == mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC)
00896     {
00897       std::string useSampling = ReadXMLStringAttribut( "USESAMPLING", atts );
00898       double useSamp = atof(useSampling.c_str());
00899       metricValues[2] = useSamp;
00900       std::string spatialSamples = ReadXMLStringAttribut( "SPATIALSAMPLES", atts );
00901       double spatSamp = atof(spatialSamples.c_str());
00902       metricValues[3] = spatSamp;
00903       std::string histogramBins = ReadXMLStringAttribut( "HISTOGRAMBINS", atts );
00904       double histBins = atof(histogramBins.c_str());
00905       metricValues[4] = histBins;
00906     }
00907     else if (metric == mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC)
00908     {
00909       std::string lambda = ReadXMLStringAttribut( "LAMBDA", atts );
00910       double lamb = atof(lambda.c_str());
00911       metricValues[2] = lamb;
00912     }
00913     else if (metric == mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC)
00914     {
00915       std::string spatialSamples = ReadXMLStringAttribut( "SPATIALSAMPLES", atts );
00916       double spatSamp = atof(spatialSamples.c_str());
00917       metricValues[2] = spatSamp;
00918       std::string fixedStandardDeviation = ReadXMLStringAttribut( "FIXEDSTANDARDDEVIATION", atts );
00919       double fiStaDev = atof(fixedStandardDeviation.c_str());
00920       metricValues[3] = fiStaDev;
00921       std::string movingStandardDeviation = ReadXMLStringAttribut( "MOVINGSTANDARDDEVIATION", atts );
00922       double moStaDev = atof(movingStandardDeviation.c_str());
00923       metricValues[4] = moStaDev;
00924       std::string useNormalizer = ReadXMLStringAttribut( "USENORMALIZERANDSMOOTHER", atts );
00925       double useNormal = atof(useNormalizer.c_str());
00926       metricValues[5] = useNormal;
00927       std::string fixedSmootherVariance = ReadXMLStringAttribut( "FIXEDSMOOTHERVARIANCE", atts );
00928       double fiSmoVa = atof(fixedSmootherVariance.c_str());
00929       metricValues[6] = fiSmoVa;
00930       std::string movingSmootherVariance = ReadXMLStringAttribut( "MOVINGSMOOTHERVARIANCE", atts );
00931       double moSmoVa = atof(movingSmootherVariance.c_str());
00932       metricValues[7] = moSmoVa;
00933     }
00934     return metricValues;
00935   }
00936 
00937   itk::Array<double> RigidRegistrationPreset::loadOptimizerValues(itk::Array<double> optimizerValues, double optimizer, const char **atts)
00938   {
00939     std::string maximize = ReadXMLStringAttribut( "MAXIMIZE", atts );
00940     double max = atof(maximize.c_str());
00941     optimizerValues[1] = max;
00942     if (optimizer == mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER)
00943     {
00944       std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
00945       double stepLe = atof(stepLength.c_str());
00946       optimizerValues[2] = stepLe;
00947       std::string numberOfSteps = ReadXMLStringAttribut( "NUMBEROFSTEPS", atts );
00948       double numSteps = atof(numberOfSteps.c_str());
00949       optimizerValues[3] = numSteps;
00950     }
00951     else if (optimizer == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER
00952             || optimizer == mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
00953     {
00954       std::string learningRate = ReadXMLStringAttribut( "LEARNINGRATE", atts );
00955       double learn = atof(learningRate.c_str());
00956       optimizerValues[2] = learn;
00957       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
00958       double numIt = atof(numberIterations.c_str());
00959       optimizerValues[3] = numIt;
00960     }
00961     else if (optimizer == mitk::OptimizerParameters::LBFGSBOPTIMIZER)
00962     {
00963     }
00964     else if (optimizer == mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
00965     {
00966       std::string shrinkFactor = ReadXMLStringAttribut( "SHRINKFACTOR", atts );
00967       double shrink = atof(shrinkFactor.c_str());
00968       optimizerValues[2] = shrink;
00969       std::string growthFactor = ReadXMLStringAttribut( "GROWTHFACTOR", atts );
00970       double growth = atof(growthFactor.c_str());
00971       optimizerValues[3] = growth;
00972       std::string epsilon = ReadXMLStringAttribut( "EPSILON", atts );
00973       double eps = atof(epsilon.c_str());
00974       optimizerValues[4] = eps;
00975       std::string initialRadius = ReadXMLStringAttribut( "INITIALRADIUS", atts );
00976       double initRad = atof(initialRadius.c_str());
00977       optimizerValues[5] = initRad;
00978       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
00979       double numIt = atof(numberIterations.c_str());
00980       optimizerValues[6] = numIt;
00981     }
00982     else if (optimizer == mitk::OptimizerParameters::POWELLOPTIMIZER)
00983     {
00984       std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
00985       double stepLe = atof(stepLength.c_str());
00986       optimizerValues[2] = stepLe;
00987       std::string stepTolerance = ReadXMLStringAttribut( "STEPTOLERANCE", atts );
00988       double stepTo = atof(stepTolerance.c_str());
00989       optimizerValues[3] = stepTo;
00990       std::string valueTolerance = ReadXMLStringAttribut( "VALUETOLERANCE", atts );
00991       double valTo = atof(valueTolerance.c_str());
00992       optimizerValues[4] = valTo;
00993       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
00994       double numIt = atof(numberIterations.c_str());
00995       optimizerValues[5] = numIt;
00996     }
00997     else if (optimizer == mitk::OptimizerParameters::FRPROPTIMIZER)
00998     {
00999       std::string useFletchReeves = ReadXMLStringAttribut( "USEFLETCHREEVES", atts );
01000       double useFleRe = atof(useFletchReeves.c_str());
01001       optimizerValues[2] = useFleRe;
01002       std::string stepLength = ReadXMLStringAttribut( "STEPLENGTH", atts );
01003       double stepLe = atof(stepLength.c_str());
01004       optimizerValues[3] = stepLe;
01005       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01006       double numIt = atof(numberIterations.c_str());
01007       optimizerValues[4] = numIt;
01008     }
01009     else if (optimizer == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
01010     {
01011       std::string gradientMagnitudeTolerance = ReadXMLStringAttribut( "GRADIENTMAGNITUDETOLERANCE", atts );
01012       double graMagTo = atof(gradientMagnitudeTolerance.c_str());
01013       optimizerValues[2] = graMagTo;
01014       std::string minStepLength = ReadXMLStringAttribut( "MINSTEPLENGTH", atts );
01015       double minStep = atof(minStepLength.c_str());
01016       optimizerValues[3] = minStep;
01017       std::string maxStepLength = ReadXMLStringAttribut( "MAXSTEPLENGTH", atts );
01018       double maxStep = atof(maxStepLength.c_str());
01019       optimizerValues[4] = maxStep;
01020       std::string relaxationFactor = ReadXMLStringAttribut( "RELAXATIONFACTOR", atts );
01021       double relFac = atof(relaxationFactor.c_str());
01022       optimizerValues[5] = relFac;
01023       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01024       double numIt = atof(numberIterations.c_str());
01025       optimizerValues[6] = numIt;
01026     }
01027     else if (optimizer == mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER || optimizer == mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
01028     {
01029       std::string gradientMagnitudeTolerance = ReadXMLStringAttribut( "GRADIENTMAGNITUDETOLERANCE", atts );
01030       double graMagTo = atof(gradientMagnitudeTolerance.c_str());
01031       optimizerValues[2] = graMagTo;
01032       std::string minStepLength = ReadXMLStringAttribut( "MINSTEPLENGTH", atts );
01033       double minStep = atof(minStepLength.c_str());
01034       optimizerValues[3] = minStep;
01035       std::string maxStepLength = ReadXMLStringAttribut( "MAXSTEPLENGTH", atts );
01036       double maxStep = atof(maxStepLength.c_str());
01037       optimizerValues[4] = maxStep;
01038       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01039       double numIt = atof(numberIterations.c_str());
01040       optimizerValues[5] = numIt;
01041     }
01042     else if (optimizer == mitk::OptimizerParameters::AMOEBAOPTIMIZER)
01043     {
01044       std::string simplexDelta1 = ReadXMLStringAttribut( "SIMPLEXDELTA1", atts );
01045       double simpDel1 = atof(simplexDelta1.c_str());
01046       optimizerValues[2] = simpDel1;
01047       std::string simplexDelta2 = ReadXMLStringAttribut( "SIMPLEXDELTA2", atts );
01048       double simpDel2 = atof(simplexDelta2.c_str());
01049       optimizerValues[3] = simpDel2;
01050       std::string simplexDelta3 = ReadXMLStringAttribut( "SIMPLEXDELTA3", atts );
01051       double simpDel3 = atof(simplexDelta3.c_str());
01052       optimizerValues[4] = simpDel3;
01053       std::string simplexDelta4 = ReadXMLStringAttribut( "SIMPLEXDELTA4", atts );
01054       double simpDel4 = atof(simplexDelta4.c_str());
01055       optimizerValues[5] = simpDel4;
01056       std::string simplexDelta5 = ReadXMLStringAttribut( "SIMPLEXDELTA5", atts );
01057       double simpDel5 = atof(simplexDelta5.c_str());
01058       optimizerValues[6] = simpDel5;
01059       std::string simplexDelta6 = ReadXMLStringAttribut( "SIMPLEXDELTA6", atts );
01060       double simpDel6 = atof(simplexDelta6.c_str());
01061       optimizerValues[7] = simpDel6;
01062       std::string simplexDelta7 = ReadXMLStringAttribut( "SIMPLEXDELTA7", atts );
01063       double simpDel7 = atof(simplexDelta7.c_str());
01064       optimizerValues[8] = simpDel7;
01065       std::string simplexDelta8 = ReadXMLStringAttribut( "SIMPLEXDELTA8", atts );
01066       double simpDel8 = atof(simplexDelta8.c_str());
01067       optimizerValues[9] = simpDel8;
01068       std::string simplexDelta9 = ReadXMLStringAttribut( "SIMPLEXDELTA9", atts );
01069       double simpDel9 = atof(simplexDelta9.c_str());
01070       optimizerValues[10] = simpDel9;
01071       std::string simplexDelta10 = ReadXMLStringAttribut( "SIMPLEXDELTA10", atts );
01072       double simpDel10 = atof(simplexDelta10.c_str());
01073       optimizerValues[11] = simpDel10;
01074       std::string simplexDelta11 = ReadXMLStringAttribut( "SIMPLEXDELTA11", atts );
01075       double simpDel11 = atof(simplexDelta11.c_str());
01076       optimizerValues[12] = simpDel11;
01077       std::string simplexDelta12 = ReadXMLStringAttribut( "SIMPLEXDELTA12", atts );
01078       double simpDel12 = atof(simplexDelta12.c_str());
01079       optimizerValues[13] = simpDel12;
01080       std::string simplexDelta13 = ReadXMLStringAttribut( "SIMPLEXDELTA13", atts );
01081       double simpDel13 = atof(simplexDelta13.c_str());
01082       optimizerValues[14] = simpDel13;
01083       std::string simplexDelta14 = ReadXMLStringAttribut( "SIMPLEXDELTA14", atts );
01084       double simpDel14 = atof(simplexDelta14.c_str());
01085       optimizerValues[15] = simpDel14;
01086       std::string simplexDelta15 = ReadXMLStringAttribut( "SIMPLEXDELTA15", atts );
01087       double simpDel15 = atof(simplexDelta15.c_str());
01088       optimizerValues[16] = simpDel15;
01089       std::string simplexDelta16 = ReadXMLStringAttribut( "SIMPLEXDELTA16", atts );
01090       double simpDel16 = atof(simplexDelta16.c_str());
01091       optimizerValues[17] = simpDel16;
01092       std::string parametersConvergenceTolerance = ReadXMLStringAttribut( "PARAMETERSCONVERGENCETOLERANCE", atts );
01093       double paramConv = atof(parametersConvergenceTolerance.c_str());
01094       optimizerValues[18] = paramConv;
01095       std::string functionConvergenceTolerance = ReadXMLStringAttribut( "FUNCTIONCONVERGENCETOLERANCE", atts );
01096       double funcConv = atof(functionConvergenceTolerance.c_str());
01097       optimizerValues[19] = funcConv;
01098       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01099       double numIt = atof(numberIterations.c_str());
01100       optimizerValues[20] = numIt;
01101     }
01102     else if (optimizer == mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
01103     {
01104     }
01105     else if (optimizer == mitk::OptimizerParameters::LBFGSOPTIMIZER)
01106     {
01107       std::string GradientConvergenceTolerance = ReadXMLStringAttribut( "GRADIENTCONVERGENCETOLERANCE", atts );
01108       double graConTo = atof(GradientConvergenceTolerance.c_str());
01109       optimizerValues[2] = graConTo;
01110       std::string lineSearchAccuracy = ReadXMLStringAttribut( "LINESEARCHACCURACY", atts );
01111       double lineSearch = atof(lineSearchAccuracy.c_str());
01112       optimizerValues[3] = lineSearch;
01113       std::string defaultStepLength = ReadXMLStringAttribut( "DEFAULTSTEPLENGTH", atts );
01114       double defStep = atof(defaultStepLength.c_str());
01115       optimizerValues[4] = defStep;
01116       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01117       double numIt = atof(numberIterations.c_str());
01118       optimizerValues[5] = numIt;
01119       std::string useTrace = ReadXMLStringAttribut( "USETRACE", atts );
01120       double useTr = atof(useTrace.c_str());
01121       optimizerValues[6] = useTr;
01122     }
01123     else if (optimizer == mitk::OptimizerParameters::SPSAOPTIMIZER)
01124     {
01125       std::string a = ReadXMLStringAttribut( "a", atts );
01126       double a1 = atof(a.c_str());
01127       optimizerValues[2] = a1;
01128       std::string a2 = ReadXMLStringAttribut( "A", atts );
01129       double a3 = atof(a2.c_str());
01130       optimizerValues[3] = a3;
01131       std::string alpha = ReadXMLStringAttribut( "ALPHA", atts );
01132       double alp = atof(alpha.c_str());
01133       optimizerValues[4] = alp;
01134       std::string c = ReadXMLStringAttribut( "c", atts );
01135       double c1 = atof(c.c_str());
01136       optimizerValues[5] = c1;
01137       std::string gamma = ReadXMLStringAttribut( "GAMMA", atts );
01138       double gam = atof(gamma.c_str());
01139       optimizerValues[6] = gam;
01140       std::string tolerance = ReadXMLStringAttribut( "TOLERANCE", atts );
01141       double tol = atof(tolerance.c_str());
01142       optimizerValues[7] = tol;
01143       std::string stateOfConvergenceDecayRate = ReadXMLStringAttribut( "STATEOFCONVERGENCEDECAYRATE", atts );
01144       double stateOfConvergence = atof(stateOfConvergenceDecayRate.c_str());
01145       optimizerValues[8] = stateOfConvergence;
01146       std::string minNumberIterations = ReadXMLStringAttribut( "MINNUMBERITERATIONS", atts );
01147       double minNumIt = atof(minNumberIterations.c_str());
01148       optimizerValues[9] = minNumIt;
01149       std::string numberPerturbations = ReadXMLStringAttribut( "NUMBERPERTURBATIONS", atts );
01150       double numPer = atof(numberPerturbations.c_str());
01151       optimizerValues[10] = numPer;
01152       std::string numberIterations = ReadXMLStringAttribut( "NUMBERITERATIONS", atts );
01153       double numIt = atof(numberIterations.c_str());
01154       optimizerValues[11] = numIt;
01155     }
01156     return optimizerValues;
01157   }
01158 
01159   itk::Array<double> RigidRegistrationPreset::loadInterpolatorValues(itk::Array<double> interpolatorValues/*, double interpolator, const char **atts*/)
01160   {
01161     return interpolatorValues;
01162   }
01163 }