Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
mitkRigidRegistrationPreset.cpp
Go to the documentation of this file.
1 /*===================================================================
2 
3 The Medical Imaging Interaction Toolkit (MITK)
4 
5 Copyright (c) German Cancer Research Center,
6 Division of Medical and Biological Informatics.
7 All rights reserved.
8 
9 This software is distributed WITHOUT ANY WARRANTY; without
10 even the implied warranty of MERCHANTABILITY or FITNESS FOR
11 A PARTICULAR PURPOSE.
12 
13 See LICENSE.txt or http://www.mitk.org for details.
14 
15 ===================================================================*/
16 
17 #include "mitkRigidRegistrationPreset.h"
18 #include "mitkMetricParameters.h"
19 #include "mitkOptimizerParameters.h"
20 #include "mitkTransformParameters.h"
21 
22 #include "usGetModuleContext.h"
23 #include "usModule.h"
24 #include "usModuleContext.h"
25 #include "usModuleResource.h"
26 #include "usModuleResourceStream.h"
27 
28 namespace mitk
29 {
30  RigidRegistrationPreset::RigidRegistrationPreset()
31  {
32  m_Name = "";
33  m_XmlFileName = "mitkRigidRegistrationPresets.xml";
34  }
35 
36  RigidRegistrationPreset::~RigidRegistrationPreset() {}
37  bool RigidRegistrationPreset::LoadPreset() { return LoadPreset("mitkRigidRegistrationPresets.xml"); }
38  bool RigidRegistrationPreset::LoadPreset(std::string fileName)
39  {
40  if (fileName.empty())
41  return false;
42 
43  us::ModuleResource presetResource = us::GetModuleContext()->GetModule()->GetResource(fileName);
44  if (!presetResource)
45  return false;
46 
47  us::ModuleResourceStream presetStream(presetResource);
48 
49  vtkXMLParser::SetStream(&presetStream);
50 
51  if (!vtkXMLParser::Parse())
52  {
53 #ifdef INTERDEBUG
54  MITK_INFO << "RigidRegistrationPreset::LoadPreset xml file cannot parse!" << std::endl;
55 #endif
56  }
57 
58  return true;
59  }
60 
61  bool RigidRegistrationPreset::newPresets(std::map<std::string, itk::Array<double>> newTransformValues,
62  std::map<std::string, itk::Array<double>> newMetricValues,
63  std::map<std::string, itk::Array<double>> newOptimizerValues,
64  std::map<std::string, itk::Array<double>> newInterpolatorValues,
65  std::string fileName)
66  {
67  if (!fileName.empty())
68  {
69  m_XmlFileName = fileName;
70  }
71  m_TransformValues = newTransformValues;
72  m_MetricValues = newMetricValues;
73  m_OptimizerValues = newOptimizerValues;
74  m_InterpolatorValues = newInterpolatorValues;
75  return save();
76  }
77 
78  void RigidRegistrationPreset::StartElement(const char *elementName, const char **atts)
79  {
80  std::string elementNameString = elementName;
81  if (elementNameString == "preset")
82  {
83  m_Name = ReadXMLStringAttribut("NAME", atts);
84  }
85  else if (elementNameString == "transform")
86  {
87  itk::Array<double> transformValues;
88  transformValues.SetSize(25);
89  transformValues.fill(0);
90  std::string transform = ReadXMLStringAttribut("TRANSFORM", atts);
91  double trans = atof(transform.c_str());
92  transformValues[0] = trans;
93  MITK_DEBUG("RigidRegistration.Preset.StartElement ") << "Name tag: " << m_Name;
94  transformValues = this->loadTransformValues(transformValues, trans, atts);
95  m_TransformValues[m_Name] = transformValues;
96  }
97  else if (elementNameString == "metric")
98  {
99  itk::Array<double> metricValues;
100  metricValues.SetSize(25);
101  metricValues.fill(0);
102  std::string metric = ReadXMLStringAttribut("METRIC", atts);
103  double met = atof(metric.c_str());
104  metricValues[0] = met;
105  metricValues = this->loadMetricValues(metricValues, met, atts);
106  m_MetricValues[m_Name] = metricValues;
107  }
108  else if (elementNameString == "optimizer")
109  {
110  itk::Array<double> optimizerValues;
111  optimizerValues.SetSize(25);
112  optimizerValues.fill(0);
113  std::string optimizer = ReadXMLStringAttribut("OPTIMIZER", atts);
114  double opt = atof(optimizer.c_str());
115  optimizerValues[0] = opt;
116  optimizerValues = this->loadOptimizerValues(optimizerValues, opt, atts);
117  m_OptimizerValues[m_Name] = optimizerValues;
118  }
119  else if (elementNameString == "interpolator")
120  {
121  itk::Array<double> interpolatorValues;
122  interpolatorValues.SetSize(25);
123  interpolatorValues.fill(0);
124  std::string interpolator = ReadXMLStringAttribut("INTERPOLATOR", atts);
125  double inter = atof(interpolator.c_str());
126  interpolatorValues[0] = inter;
127  interpolatorValues = this->loadInterpolatorValues(interpolatorValues /*, inter, atts*/);
128  m_InterpolatorValues[m_Name] = interpolatorValues;
129  }
130  }
131 
132  std::string RigidRegistrationPreset::ReadXMLStringAttribut(std::string name, const char **atts)
133  {
134  if (atts)
135  {
136  const char **attsIter = atts;
137 
138  while (*attsIter)
139  {
140  if (name == *attsIter)
141  {
142  attsIter++;
143  return *attsIter;
144  }
145  attsIter++;
146  attsIter++;
147  }
148  }
149 
150  return std::string();
151  }
152 
153  itk::Array<double> RigidRegistrationPreset::getTransformValues(std::string name) { return m_TransformValues[name]; }
154  itk::Array<double> RigidRegistrationPreset::getMetricValues(std::string name) { return m_MetricValues[name]; }
155  itk::Array<double> RigidRegistrationPreset::getOptimizerValues(std::string name) { return m_OptimizerValues[name]; }
156  itk::Array<double> RigidRegistrationPreset::getInterpolatorValues(std::string name)
157  {
158  return m_InterpolatorValues[name];
159  }
160 
161  std::list<std::string> &RigidRegistrationPreset::getAvailablePresets()
162  {
163  // use the loaded transoform values to access the names
164 
165  for (auto preset : m_TransformValues)
166  {
167  m_LoadedPresets.push_back(preset.first);
168  }
169 
170  return m_LoadedPresets;
171  }
172 
173  std::map<std::string, itk::Array<double>> &RigidRegistrationPreset::getTransformValuesPresets()
174  {
175  return m_TransformValues;
176  }
177 
178  std::map<std::string, itk::Array<double>> &RigidRegistrationPreset::getMetricValuesPresets()
179  {
180  return m_MetricValues;
181  }
182 
183  std::map<std::string, itk::Array<double>> &RigidRegistrationPreset::getOptimizerValuesPresets()
184  {
185  return m_OptimizerValues;
186  }
187 
188  std::map<std::string, itk::Array<double>> &RigidRegistrationPreset::getInterpolatorValuesPresets()
189  {
190  return m_InterpolatorValues;
191  }
192 
193  bool RigidRegistrationPreset::save()
194  {
195  // falsely removed return value, the previous implementation was also empty (and only returning false)
196  return false;
197  }
198 
199  itk::Array<double> RigidRegistrationPreset::loadTransformValues(itk::Array<double> transformValues,
200  double transform,
201  const char **atts)
202  {
203  if (transform == mitk::TransformParameters::TRANSLATIONTRANSFORM ||
204  transform == mitk::TransformParameters::SCALETRANSFORM ||
205  transform == mitk::TransformParameters::SCALELOGARITHMICTRANSFORM ||
206  transform == mitk::TransformParameters::VERSORTRANSFORM ||
207  transform == mitk::TransformParameters::RIGID2DTRANSFORM ||
208  transform == mitk::TransformParameters::EULER2DTRANSFORM)
209  {
210  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
211  double useSca = atof(useScales.c_str());
212  transformValues[1] = useSca;
213  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
214  double sca1 = atof(scale1.c_str());
215  transformValues[2] = sca1;
216  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
217  double sca2 = atof(scale2.c_str());
218  transformValues[3] = sca2;
219  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
220  double sca3 = atof(scale3.c_str());
221  transformValues[4] = sca3;
222  }
223  else if (transform == mitk::TransformParameters::AFFINETRANSFORM ||
224  transform == mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM)
225  {
226  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
227  double useSca = atof(useScales.c_str());
228  transformValues[1] = useSca;
229  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
230  double sca1 = atof(scale1.c_str());
231  transformValues[2] = sca1;
232  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
233  double sca2 = atof(scale2.c_str());
234  transformValues[3] = sca2;
235  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
236  double sca3 = atof(scale3.c_str());
237  transformValues[4] = sca3;
238  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
239  double sca4 = atof(scale4.c_str());
240  transformValues[5] = sca4;
241  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
242  double sca5 = atof(scale5.c_str());
243  transformValues[6] = sca5;
244  std::string scale6 = ReadXMLStringAttribut("SCALE6", atts);
245  double sca6 = atof(scale6.c_str());
246  transformValues[7] = sca6;
247  std::string scale7 = ReadXMLStringAttribut("SCALE7", atts);
248  double sca7 = atof(scale7.c_str());
249  transformValues[8] = sca7;
250  std::string scale8 = ReadXMLStringAttribut("SCALE8", atts);
251  double sca8 = atof(scale8.c_str());
252  transformValues[9] = sca8;
253  std::string scale9 = ReadXMLStringAttribut("SCALE9", atts);
254  double sca9 = atof(scale9.c_str());
255  transformValues[10] = sca9;
256  std::string scale10 = ReadXMLStringAttribut("SCALE10", atts);
257  double sca10 = atof(scale10.c_str());
258  transformValues[11] = sca10;
259  std::string scale11 = ReadXMLStringAttribut("SCALE11", atts);
260  double sca11 = atof(scale11.c_str());
261  transformValues[12] = sca11;
262  std::string scale12 = ReadXMLStringAttribut("SCALE12", atts);
263  double sca12 = atof(scale12.c_str());
264  transformValues[13] = sca12;
265 
266  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
267  double useIni = atof(useInitializer.c_str());
268  transformValues[14] = useIni;
269  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
270  double useMo = atof(useMoments.c_str());
271  transformValues[15] = useMo;
272  }
273 
274  else if (transform == mitk::TransformParameters::EULER3DTRANSFORM ||
275  transform == mitk::TransformParameters::CENTEREDEULER3DTRANSFORM ||
276  transform == mitk::TransformParameters::VERSORRIGID3DTRANSFORM)
277  {
278  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
279  double useSca = atof(useScales.c_str());
280  transformValues[1] = useSca;
281  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
282  double sca1 = atof(scale1.c_str());
283  transformValues[2] = sca1;
284  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
285  double sca2 = atof(scale2.c_str());
286  transformValues[3] = sca2;
287  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
288  double sca3 = atof(scale3.c_str());
289  transformValues[4] = sca3;
290  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
291  double sca4 = atof(scale4.c_str());
292  transformValues[5] = sca4;
293  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
294  double sca5 = atof(scale5.c_str());
295  transformValues[6] = sca5;
296  std::string scale6 = ReadXMLStringAttribut("SCALE6", atts);
297  double sca6 = atof(scale6.c_str());
298  transformValues[7] = sca6;
299  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
300  double useIni = atof(useInitializer.c_str());
301  transformValues[8] = useIni;
302  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
303  double useMo = atof(useMoments.c_str());
304  transformValues[9] = useMo;
305  }
306  else if (transform == mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM ||
307  transform == mitk::TransformParameters::SIMILARITY3DTRANSFORM)
308  {
309  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
310  double useSca = atof(useScales.c_str());
311  transformValues[1] = useSca;
312  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
313  double sca1 = atof(scale1.c_str());
314  transformValues[2] = sca1;
315  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
316  double sca2 = atof(scale2.c_str());
317  transformValues[3] = sca2;
318  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
319  double sca3 = atof(scale3.c_str());
320  transformValues[4] = sca3;
321  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
322  double sca4 = atof(scale4.c_str());
323  transformValues[5] = sca4;
324  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
325  double sca5 = atof(scale5.c_str());
326  transformValues[6] = sca5;
327  std::string scale6 = ReadXMLStringAttribut("SCALE6", atts);
328  double sca6 = atof(scale6.c_str());
329  transformValues[7] = sca6;
330  std::string scale7 = ReadXMLStringAttribut("SCALE7", atts);
331  double sca7 = atof(scale7.c_str());
332  transformValues[8] = sca7;
333  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
334  double useIni = atof(useInitializer.c_str());
335  transformValues[9] = useIni;
336  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
337  double useMo = atof(useMoments.c_str());
338  transformValues[10] = useMo;
339  }
340  else if (transform == mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM)
341  {
342  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
343  double useSca = atof(useScales.c_str());
344  transformValues[1] = useSca;
345  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
346  double sca1 = atof(scale1.c_str());
347  transformValues[2] = sca1;
348  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
349  double sca2 = atof(scale2.c_str());
350  transformValues[3] = sca2;
351  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
352  double sca3 = atof(scale3.c_str());
353  transformValues[4] = sca3;
354  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
355  double sca4 = atof(scale4.c_str());
356  transformValues[5] = sca4;
357  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
358  double sca5 = atof(scale5.c_str());
359  transformValues[6] = sca5;
360  std::string scale6 = ReadXMLStringAttribut("SCALE6", atts);
361  double sca6 = atof(scale6.c_str());
362  transformValues[7] = sca6;
363  std::string scale7 = ReadXMLStringAttribut("SCALE7", atts);
364  double sca7 = atof(scale7.c_str());
365  transformValues[8] = sca7;
366  std::string scale8 = ReadXMLStringAttribut("SCALE8", atts);
367  double sca8 = atof(scale8.c_str());
368  transformValues[9] = sca8;
369  std::string scale9 = ReadXMLStringAttribut("SCALE9", atts);
370  double sca9 = atof(scale9.c_str());
371  transformValues[10] = sca9;
372  std::string scale10 = ReadXMLStringAttribut("SCALE10", atts);
373  double sca10 = atof(scale10.c_str());
374  transformValues[11] = sca10;
375  std::string scale11 = ReadXMLStringAttribut("SCALE11", atts);
376  double sca11 = atof(scale11.c_str());
377  transformValues[12] = sca11;
378  std::string scale12 = ReadXMLStringAttribut("SCALE12", atts);
379  double sca12 = atof(scale12.c_str());
380  transformValues[13] = sca12;
381  std::string scale13 = ReadXMLStringAttribut("SCALE13", atts);
382  double sca13 = atof(scale13.c_str());
383  transformValues[14] = sca13;
384  std::string scale14 = ReadXMLStringAttribut("SCALE14", atts);
385  double sca14 = atof(scale14.c_str());
386  transformValues[15] = sca14;
387  std::string scale15 = ReadXMLStringAttribut("SCALE15", atts);
388  double sca15 = atof(scale15.c_str());
389  transformValues[16] = sca15;
390  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
391  double useIni = atof(useInitializer.c_str());
392  transformValues[17] = useIni;
393  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
394  double useMo = atof(useMoments.c_str());
395  transformValues[18] = useMo;
396  }
397  else if (transform == mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM)
398  {
399  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
400  double useSca = atof(useScales.c_str());
401  transformValues[1] = useSca;
402  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
403  double sca1 = atof(scale1.c_str());
404  transformValues[2] = sca1;
405  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
406  double sca2 = atof(scale2.c_str());
407  transformValues[3] = sca2;
408  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
409  double sca3 = atof(scale3.c_str());
410  transformValues[4] = sca3;
411  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
412  double sca4 = atof(scale4.c_str());
413  transformValues[5] = sca4;
414  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
415  double sca5 = atof(scale5.c_str());
416  transformValues[6] = sca5;
417  std::string angle = ReadXMLStringAttribut("ANGLE", atts);
418  double ang = atof(angle.c_str());
419  transformValues[7] = ang;
420  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
421  double useIni = atof(useInitializer.c_str());
422  transformValues[8] = useIni;
423  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
424  double useMo = atof(useMoments.c_str());
425  transformValues[9] = useMo;
426  }
427  else if (transform == mitk::TransformParameters::SIMILARITY2DTRANSFORM)
428  {
429  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
430  double useSca = atof(useScales.c_str());
431  transformValues[1] = useSca;
432  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
433  double sca1 = atof(scale1.c_str());
434  transformValues[2] = sca1;
435  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
436  double sca2 = atof(scale2.c_str());
437  transformValues[3] = sca2;
438  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
439  double sca3 = atof(scale3.c_str());
440  transformValues[4] = sca3;
441  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
442  double sca4 = atof(scale4.c_str());
443  transformValues[5] = sca4;
444  std::string scale = ReadXMLStringAttribut("SCALE", atts);
445  double sca = atof(scale.c_str());
446  transformValues[6] = sca;
447  std::string angle = ReadXMLStringAttribut("ANGLE", atts);
448  double ang = atof(angle.c_str());
449  transformValues[7] = ang;
450  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
451  double useIni = atof(useInitializer.c_str());
452  transformValues[8] = useIni;
453  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
454  double useMo = atof(useMoments.c_str());
455  transformValues[9] = useMo;
456  }
457  else if (transform == mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM)
458  {
459  std::string useScales = ReadXMLStringAttribut("USESCALES", atts);
460  double useSca = atof(useScales.c_str());
461  transformValues[1] = useSca;
462  std::string scale1 = ReadXMLStringAttribut("SCALE1", atts);
463  double sca1 = atof(scale1.c_str());
464  transformValues[2] = sca1;
465  std::string scale2 = ReadXMLStringAttribut("SCALE2", atts);
466  double sca2 = atof(scale2.c_str());
467  transformValues[3] = sca2;
468  std::string scale3 = ReadXMLStringAttribut("SCALE3", atts);
469  double sca3 = atof(scale3.c_str());
470  transformValues[4] = sca3;
471  std::string scale4 = ReadXMLStringAttribut("SCALE4", atts);
472  double sca4 = atof(scale4.c_str());
473  transformValues[5] = sca4;
474  std::string scale5 = ReadXMLStringAttribut("SCALE5", atts);
475  double sca5 = atof(scale5.c_str());
476  transformValues[6] = sca5;
477  std::string scale6 = ReadXMLStringAttribut("SCALE6", atts);
478  double sca6 = atof(scale6.c_str());
479  transformValues[7] = sca6;
480  std::string scale = ReadXMLStringAttribut("SCALE", atts);
481  double sca = atof(scale.c_str());
482  transformValues[8] = sca;
483  std::string angle = ReadXMLStringAttribut("ANGLE", atts);
484  double ang = atof(angle.c_str());
485  transformValues[9] = ang;
486  std::string useInitializer = ReadXMLStringAttribut("USEINITIALIZER", atts);
487  double useIni = atof(useInitializer.c_str());
488  transformValues[10] = useIni;
489  std::string useMoments = ReadXMLStringAttribut("USEMOMENTS", atts);
490  double useMo = atof(useMoments.c_str());
491  transformValues[11] = useMo;
492  }
493 
494  MITK_DEBUG("RigidRegistration.Preset.LoadValue ") << transformValues;
495  return transformValues;
496  }
497 
498  itk::Array<double> RigidRegistrationPreset::loadMetricValues(itk::Array<double> metricValues,
499  double metric,
500  const char **atts)
501  {
502  std::string computeGradient = ReadXMLStringAttribut("COMPUTEGRADIENT", atts);
503  double compGra = atof(computeGradient.c_str());
504  metricValues[1] = compGra;
505  if (metric == mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC ||
506  metric == mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC ||
507  metric == mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC ||
508  metric == mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC ||
509  metric == mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC)
510  {
511  }
512  else if (metric == mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC ||
513  metric == mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC ||
514  metric == mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC ||
515  metric == mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC ||
516  metric == mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC)
517  {
518  std::string histogramBins = ReadXMLStringAttribut("HISTOGRAMBINS", atts);
519  double histBins = atof(histogramBins.c_str());
520  metricValues[2] = histBins;
521  }
522  else if (metric == mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC)
523  {
524  std::string useSampling = ReadXMLStringAttribut("USESAMPLING", atts);
525  double useSamp = atof(useSampling.c_str());
526  metricValues[2] = useSamp;
527  std::string spatialSamples = ReadXMLStringAttribut("SPATIALSAMPLES", atts);
528  double spatSamp = atof(spatialSamples.c_str());
529  metricValues[3] = spatSamp;
530  std::string histogramBins = ReadXMLStringAttribut("HISTOGRAMBINS", atts);
531  double histBins = atof(histogramBins.c_str());
532  metricValues[4] = histBins;
533  }
534  else if (metric == mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC)
535  {
536  std::string lambda = ReadXMLStringAttribut("LAMBDA", atts);
537  double lamb = atof(lambda.c_str());
538  metricValues[2] = lamb;
539  }
540  else if (metric == mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC)
541  {
542  std::string spatialSamples = ReadXMLStringAttribut("SPATIALSAMPLES", atts);
543  double spatSamp = atof(spatialSamples.c_str());
544  metricValues[2] = spatSamp;
545  std::string fixedStandardDeviation = ReadXMLStringAttribut("FIXEDSTANDARDDEVIATION", atts);
546  double fiStaDev = atof(fixedStandardDeviation.c_str());
547  metricValues[3] = fiStaDev;
548  std::string movingStandardDeviation = ReadXMLStringAttribut("MOVINGSTANDARDDEVIATION", atts);
549  double moStaDev = atof(movingStandardDeviation.c_str());
550  metricValues[4] = moStaDev;
551  std::string useNormalizer = ReadXMLStringAttribut("USENORMALIZERANDSMOOTHER", atts);
552  double useNormal = atof(useNormalizer.c_str());
553  metricValues[5] = useNormal;
554  std::string fixedSmootherVariance = ReadXMLStringAttribut("FIXEDSMOOTHERVARIANCE", atts);
555  double fiSmoVa = atof(fixedSmootherVariance.c_str());
556  metricValues[6] = fiSmoVa;
557  std::string movingSmootherVariance = ReadXMLStringAttribut("MOVINGSMOOTHERVARIANCE", atts);
558  double moSmoVa = atof(movingSmootherVariance.c_str());
559  metricValues[7] = moSmoVa;
560  }
561  return metricValues;
562  }
563 
564  itk::Array<double> RigidRegistrationPreset::loadOptimizerValues(itk::Array<double> optimizerValues,
565  double optimizer,
566  const char **atts)
567  {
568  std::string maximize = ReadXMLStringAttribut("MAXIMIZE", atts);
569  double max = atof(maximize.c_str());
570  optimizerValues[1] = max;
571  if (optimizer == mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER)
572  {
573  std::string stepLength = ReadXMLStringAttribut("STEPLENGTH", atts);
574  double stepLe = atof(stepLength.c_str());
575  optimizerValues[2] = stepLe;
576  std::string numberOfSteps = ReadXMLStringAttribut("NUMBEROFSTEPS", atts);
577  double numSteps = atof(numberOfSteps.c_str());
578  optimizerValues[3] = numSteps;
579  }
580  else if (optimizer == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER ||
581  optimizer == mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
582  {
583  std::string learningRate = ReadXMLStringAttribut("LEARNINGRATE", atts);
584  double learn = atof(learningRate.c_str());
585  optimizerValues[2] = learn;
586  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
587  double numIt = atof(numberIterations.c_str());
588  optimizerValues[3] = numIt;
589  }
590  else if (optimizer == mitk::OptimizerParameters::LBFGSBOPTIMIZER)
591  {
592  }
593  else if (optimizer == mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
594  {
595  std::string shrinkFactor = ReadXMLStringAttribut("SHRINKFACTOR", atts);
596  double shrink = atof(shrinkFactor.c_str());
597  optimizerValues[2] = shrink;
598  std::string growthFactor = ReadXMLStringAttribut("GROWTHFACTOR", atts);
599  double growth = atof(growthFactor.c_str());
600  optimizerValues[3] = growth;
601  std::string epsilon = ReadXMLStringAttribut("EPSILON", atts);
602  double eps = atof(epsilon.c_str());
603  optimizerValues[4] = eps;
604  std::string initialRadius = ReadXMLStringAttribut("INITIALRADIUS", atts);
605  double initRad = atof(initialRadius.c_str());
606  optimizerValues[5] = initRad;
607  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
608  double numIt = atof(numberIterations.c_str());
609  optimizerValues[6] = numIt;
610  }
611  else if (optimizer == mitk::OptimizerParameters::POWELLOPTIMIZER)
612  {
613  std::string stepLength = ReadXMLStringAttribut("STEPLENGTH", atts);
614  double stepLe = atof(stepLength.c_str());
615  optimizerValues[2] = stepLe;
616  std::string stepTolerance = ReadXMLStringAttribut("STEPTOLERANCE", atts);
617  double stepTo = atof(stepTolerance.c_str());
618  optimizerValues[3] = stepTo;
619  std::string valueTolerance = ReadXMLStringAttribut("VALUETOLERANCE", atts);
620  double valTo = atof(valueTolerance.c_str());
621  optimizerValues[4] = valTo;
622  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
623  double numIt = atof(numberIterations.c_str());
624  optimizerValues[5] = numIt;
625  }
626  else if (optimizer == mitk::OptimizerParameters::FRPROPTIMIZER)
627  {
628  std::string useFletchReeves = ReadXMLStringAttribut("USEFLETCHREEVES", atts);
629  double useFleRe = atof(useFletchReeves.c_str());
630  optimizerValues[2] = useFleRe;
631  std::string stepLength = ReadXMLStringAttribut("STEPLENGTH", atts);
632  double stepLe = atof(stepLength.c_str());
633  optimizerValues[3] = stepLe;
634  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
635  double numIt = atof(numberIterations.c_str());
636  optimizerValues[4] = numIt;
637  }
638  else if (optimizer == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
639  {
640  std::string gradientMagnitudeTolerance = ReadXMLStringAttribut("GRADIENTMAGNITUDETOLERANCE", atts);
641  double graMagTo = atof(gradientMagnitudeTolerance.c_str());
642  optimizerValues[2] = graMagTo;
643  std::string minStepLength = ReadXMLStringAttribut("MINSTEPLENGTH", atts);
644  double minStep = atof(minStepLength.c_str());
645  optimizerValues[3] = minStep;
646  std::string maxStepLength = ReadXMLStringAttribut("MAXSTEPLENGTH", atts);
647  double maxStep = atof(maxStepLength.c_str());
648  optimizerValues[4] = maxStep;
649  std::string relaxationFactor = ReadXMLStringAttribut("RELAXATIONFACTOR", atts);
650  double relFac = atof(relaxationFactor.c_str());
651  optimizerValues[5] = relFac;
652  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
653  double numIt = atof(numberIterations.c_str());
654  optimizerValues[6] = numIt;
655  }
656  else if (optimizer == mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER ||
657  optimizer == mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
658  {
659  std::string gradientMagnitudeTolerance = ReadXMLStringAttribut("GRADIENTMAGNITUDETOLERANCE", atts);
660  double graMagTo = atof(gradientMagnitudeTolerance.c_str());
661  optimizerValues[2] = graMagTo;
662  std::string minStepLength = ReadXMLStringAttribut("MINSTEPLENGTH", atts);
663  double minStep = atof(minStepLength.c_str());
664  optimizerValues[3] = minStep;
665  std::string maxStepLength = ReadXMLStringAttribut("MAXSTEPLENGTH", atts);
666  double maxStep = atof(maxStepLength.c_str());
667  optimizerValues[4] = maxStep;
668  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
669  double numIt = atof(numberIterations.c_str());
670  optimizerValues[5] = numIt;
671  }
672  else if (optimizer == mitk::OptimizerParameters::AMOEBAOPTIMIZER)
673  {
674  std::string simplexDelta1 = ReadXMLStringAttribut("SIMPLEXDELTA1", atts);
675  double simpDel1 = atof(simplexDelta1.c_str());
676  optimizerValues[2] = simpDel1;
677  std::string simplexDelta2 = ReadXMLStringAttribut("SIMPLEXDELTA2", atts);
678  double simpDel2 = atof(simplexDelta2.c_str());
679  optimizerValues[3] = simpDel2;
680  std::string simplexDelta3 = ReadXMLStringAttribut("SIMPLEXDELTA3", atts);
681  double simpDel3 = atof(simplexDelta3.c_str());
682  optimizerValues[4] = simpDel3;
683  std::string simplexDelta4 = ReadXMLStringAttribut("SIMPLEXDELTA4", atts);
684  double simpDel4 = atof(simplexDelta4.c_str());
685  optimizerValues[5] = simpDel4;
686  std::string simplexDelta5 = ReadXMLStringAttribut("SIMPLEXDELTA5", atts);
687  double simpDel5 = atof(simplexDelta5.c_str());
688  optimizerValues[6] = simpDel5;
689  std::string simplexDelta6 = ReadXMLStringAttribut("SIMPLEXDELTA6", atts);
690  double simpDel6 = atof(simplexDelta6.c_str());
691  optimizerValues[7] = simpDel6;
692  std::string simplexDelta7 = ReadXMLStringAttribut("SIMPLEXDELTA7", atts);
693  double simpDel7 = atof(simplexDelta7.c_str());
694  optimizerValues[8] = simpDel7;
695  std::string simplexDelta8 = ReadXMLStringAttribut("SIMPLEXDELTA8", atts);
696  double simpDel8 = atof(simplexDelta8.c_str());
697  optimizerValues[9] = simpDel8;
698  std::string simplexDelta9 = ReadXMLStringAttribut("SIMPLEXDELTA9", atts);
699  double simpDel9 = atof(simplexDelta9.c_str());
700  optimizerValues[10] = simpDel9;
701  std::string simplexDelta10 = ReadXMLStringAttribut("SIMPLEXDELTA10", atts);
702  double simpDel10 = atof(simplexDelta10.c_str());
703  optimizerValues[11] = simpDel10;
704  std::string simplexDelta11 = ReadXMLStringAttribut("SIMPLEXDELTA11", atts);
705  double simpDel11 = atof(simplexDelta11.c_str());
706  optimizerValues[12] = simpDel11;
707  std::string simplexDelta12 = ReadXMLStringAttribut("SIMPLEXDELTA12", atts);
708  double simpDel12 = atof(simplexDelta12.c_str());
709  optimizerValues[13] = simpDel12;
710  std::string simplexDelta13 = ReadXMLStringAttribut("SIMPLEXDELTA13", atts);
711  double simpDel13 = atof(simplexDelta13.c_str());
712  optimizerValues[14] = simpDel13;
713  std::string simplexDelta14 = ReadXMLStringAttribut("SIMPLEXDELTA14", atts);
714  double simpDel14 = atof(simplexDelta14.c_str());
715  optimizerValues[15] = simpDel14;
716  std::string simplexDelta15 = ReadXMLStringAttribut("SIMPLEXDELTA15", atts);
717  double simpDel15 = atof(simplexDelta15.c_str());
718  optimizerValues[16] = simpDel15;
719  std::string simplexDelta16 = ReadXMLStringAttribut("SIMPLEXDELTA16", atts);
720  double simpDel16 = atof(simplexDelta16.c_str());
721  optimizerValues[17] = simpDel16;
722  std::string parametersConvergenceTolerance = ReadXMLStringAttribut("PARAMETERSCONVERGENCETOLERANCE", atts);
723  double paramConv = atof(parametersConvergenceTolerance.c_str());
724  optimizerValues[18] = paramConv;
725  std::string functionConvergenceTolerance = ReadXMLStringAttribut("FUNCTIONCONVERGENCETOLERANCE", atts);
726  double funcConv = atof(functionConvergenceTolerance.c_str());
727  optimizerValues[19] = funcConv;
728  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
729  double numIt = atof(numberIterations.c_str());
730  optimizerValues[20] = numIt;
731  }
732  else if (optimizer == mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
733  {
734  }
735  else if (optimizer == mitk::OptimizerParameters::LBFGSOPTIMIZER)
736  {
737  std::string GradientConvergenceTolerance = ReadXMLStringAttribut("GRADIENTCONVERGENCETOLERANCE", atts);
738  double graConTo = atof(GradientConvergenceTolerance.c_str());
739  optimizerValues[2] = graConTo;
740  std::string lineSearchAccuracy = ReadXMLStringAttribut("LINESEARCHACCURACY", atts);
741  double lineSearch = atof(lineSearchAccuracy.c_str());
742  optimizerValues[3] = lineSearch;
743  std::string defaultStepLength = ReadXMLStringAttribut("DEFAULTSTEPLENGTH", atts);
744  double defStep = atof(defaultStepLength.c_str());
745  optimizerValues[4] = defStep;
746  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
747  double numIt = atof(numberIterations.c_str());
748  optimizerValues[5] = numIt;
749  std::string useTrace = ReadXMLStringAttribut("USETRACE", atts);
750  double useTr = atof(useTrace.c_str());
751  optimizerValues[6] = useTr;
752  }
753  else if (optimizer == mitk::OptimizerParameters::SPSAOPTIMIZER)
754  {
755  std::string a = ReadXMLStringAttribut("a", atts);
756  double a1 = atof(a.c_str());
757  optimizerValues[2] = a1;
758  std::string a2 = ReadXMLStringAttribut("A", atts);
759  double a3 = atof(a2.c_str());
760  optimizerValues[3] = a3;
761  std::string alpha = ReadXMLStringAttribut("ALPHA", atts);
762  double alp = atof(alpha.c_str());
763  optimizerValues[4] = alp;
764  std::string c = ReadXMLStringAttribut("c", atts);
765  double c1 = atof(c.c_str());
766  optimizerValues[5] = c1;
767  std::string gamma = ReadXMLStringAttribut("GAMMA", atts);
768  double gam = atof(gamma.c_str());
769  optimizerValues[6] = gam;
770  std::string tolerance = ReadXMLStringAttribut("TOLERANCE", atts);
771  double tol = atof(tolerance.c_str());
772  optimizerValues[7] = tol;
773  std::string stateOfConvergenceDecayRate = ReadXMLStringAttribut("STATEOFCONVERGENCEDECAYRATE", atts);
774  double stateOfConvergence = atof(stateOfConvergenceDecayRate.c_str());
775  optimizerValues[8] = stateOfConvergence;
776  std::string minNumberIterations = ReadXMLStringAttribut("MINNUMBERITERATIONS", atts);
777  double minNumIt = atof(minNumberIterations.c_str());
778  optimizerValues[9] = minNumIt;
779  std::string numberPerturbations = ReadXMLStringAttribut("NUMBERPERTURBATIONS", atts);
780  double numPer = atof(numberPerturbations.c_str());
781  optimizerValues[10] = numPer;
782  std::string numberIterations = ReadXMLStringAttribut("NUMBERITERATIONS", atts);
783  double numIt = atof(numberIterations.c_str());
784  optimizerValues[11] = numIt;
785  }
786  return optimizerValues;
787  }
788 
789  itk::Array<double> RigidRegistrationPreset::loadInterpolatorValues(
790  itk::Array<double> interpolatorValues /*, double interpolator, const char **atts*/)
791  {
792  return interpolatorValues;
793  }
794 }
mitk::RigidRegistrationPreset::newPresets
bool newPresets(std::map< std::string, itk::Array< double >> newTransformValues, std::map< std::string, itk::Array< double >> newMetricValues, std::map< std::string, itk::Array< double >> newOptimizerValues, std::map< std::string, itk::Array< double >> newInterpolatorValues, std::string fileName="")
Saves new presets in the previous opened xml file or in the new fileName location.
Definition: mitkRigidRegistrationPreset.cpp:61
mitk::MetricParameters::MUTUALINFORMATIONIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:62
mitk::TransformParameters::SIMILARITY3DTRANSFORM
Definition: mitkTransformParameters.h:65
mitk::RigidRegistrationPreset::LoadPreset
bool LoadPreset()
Tries to find mitkRigidRegistrationPresets.xml in /mitk/Config and loads all presets stored in this f...
Definition: mitkRigidRegistrationPreset.cpp:37
mitk::TransformParameters::CENTEREDSIMILARITY2DTRANSFORM
Definition: mitkTransformParameters.h:70
mitk::TransformParameters::SCALESKEWVERSOR3DTRANSFORM
Definition: mitkTransformParameters.h:64
mitk::TransformParameters::VERSORRIGID3DTRANSFORM
Definition: mitkTransformParameters.h:63
MITK_INFO
#define MITK_INFO
Definition: mitkLogMacros.h:22
mitk::RigidRegistrationPreset::getInterpolatorValuesPresets
std::map< std::string, itk::Array< double > > & getInterpolatorValuesPresets()
Returns a map with all preset names and their according interpolator values as an array...
Definition: mitkRigidRegistrationPreset.cpp:188
mitk::TransformParameters::VERSORTRANSFORM
Definition: mitkTransformParameters.h:62
mitk::OptimizerParameters::FRPROPTIMIZER
Definition: mitkOptimizerParameters.h:58
mitk::RigidRegistrationPreset::getMetricValuesPresets
std::map< std::string, itk::Array< double > > & getMetricValuesPresets()
Returns a map with all preset names and their according metric values as an array.
Definition: mitkRigidRegistrationPreset.cpp:178
mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER
Definition: mitkOptimizerParameters.h:59
mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER
Definition: mitkOptimizerParameters.h:65
mitk::MetricParameters::NORMALIZEDCORRELATIONIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:53
mitk::TransformParameters::SIMILARITY2DTRANSFORM
Definition: mitkTransformParameters.h:69
mitk::MetricParameters::MATTESMUTUALINFORMATIONIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:60
MITK_DEBUG
#define MITK_DEBUG
Definition: mitkLogMacros.h:26
mitk
DataCollection - Class to facilitate loading/accessing structured data.
Definition: GeometryOverview.dox:1
mitk::MetricParameters::NORMALIZEDMUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:59
mitk::TransformParameters::EULER3DTRANSFORM
Definition: mitkTransformParameters.h:59
mitk::MetricParameters::MEANSQUARESIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:52
mitk::MetricParameters::GRADIENTDIFFERENCEIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:54
mitk::RigidRegistrationPreset::getAvailablePresets
std::list< std::string > & getAvailablePresets()
Definition: mitkRigidRegistrationPreset.cpp:161
mitk::OptimizerParameters::AMOEBAOPTIMIZER
Definition: mitkOptimizerParameters.h:61
mitk::TransformParameters::CENTEREDRIGID2DTRANSFORM
Definition: mitkTransformParameters.h:67
mitk::MetricParameters::MEANRECIPROCALSQUAREDIFFERENCEIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:61
mitk::MetricParameters::MATCHCARDINALITYIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:63
mitk::TransformParameters::SCALETRANSFORM
Definition: mitkTransformParameters.h:55
mitk::TransformParameters::SCALELOGARITHMICTRANSFORM
Definition: mitkTransformParameters.h:56
ModuleContext::GetModule
Module * GetModule() const
Definition: usModuleContext.cpp:56
mitk::RigidRegistrationPreset::getOptimizerValuesPresets
std::map< std::string, itk::Array< double > > & getOptimizerValuesPresets()
Returns a map with all preset names and their according optimizer values as an array.
Definition: mitkRigidRegistrationPreset.cpp:183
mitk::RigidRegistrationPreset::getInterpolatorValues
itk::Array< double > getInterpolatorValues(std::string name)
Returns an array including all interpolator values belonging to preset name.
Definition: mitkRigidRegistrationPreset.cpp:156
mitk::OptimizerParameters::SPSAOPTIMIZER
Definition: mitkOptimizerParameters.h:64
mitk::MetricParameters::MUTUALINFORMATIONHISTOGRAMIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:58
mitk::TransformParameters::FIXEDCENTEROFROTATIONAFFINETRANSFORM
Definition: mitkTransformParameters.h:58
mitk::OptimizerParameters::LBFGSOPTIMIZER
Definition: mitkOptimizerParameters.h:63
max
static T max(T x, T y)
Definition: svm.cpp:70
mitk::MetricParameters::MEANSQUARESHISTOGRAMIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:57
mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER
Definition: mitkOptimizerParameters.h:60
mitk::TransformParameters::CENTEREDEULER3DTRANSFORM
Definition: mitkTransformParameters.h:60
mitk::TransformParameters::EULER2DTRANSFORM
Definition: mitkTransformParameters.h:68
mitk::MetricParameters::KULLBACKLEIBLERCOMPAREHISTOGRAMIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:55
mitk::OptimizerParameters::LBFGSBOPTIMIZER
Definition: mitkOptimizerParameters.h:55
mitk::TransformParameters::RIGID2DTRANSFORM
Definition: mitkTransformParameters.h:66
mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER
Definition: mitkOptimizerParameters.h:54
mitk::eps
MITKCORE_EXPORT const ScalarType eps
Definition: mitkNumericConstants.cpp:21
mitk::MetricParameters::CORRELATIONCOEFFICIENTHISTOGRAMIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:56
mitk::ImageMappingHelper::map
MITKMATCHPOINTREGISTRATION_EXPORT ResultImageType::Pointer map(const InputImageType *input, const RegistrationType *registration, bool throwOnOutOfInputAreaError=false, const double &paddingValue=0, const ResultImageGeometryType *resultGeometry=NULL, bool throwOnMappingError=true, const double &errorValue=0, mitk::ImageMappingInterpolator::Type interpolatorType=mitk::ImageMappingInterpolator::Linear)
Definition: mitkImageMappingHelper.cpp:226
mitk::TransformParameters::AFFINETRANSFORM
Definition: mitkTransformParameters.h:57
mitk::RigidRegistrationPreset::getMetricValues
itk::Array< double > getMetricValues(std::string name)
Returns an array including all all metric values belonging to preset name.
Definition: mitkRigidRegistrationPreset.cpp:154
mitk::RigidRegistrationPreset::getTransformValuesPresets
std::map< std::string, itk::Array< double > > & getTransformValuesPresets()
Returns a map with all preset names and their according transform values as an array.
Definition: mitkRigidRegistrationPreset.cpp:173
mitk::RigidRegistrationPreset::getTransformValues
itk::Array< double > getTransformValues(std::string name)
Returns an array including all all transform values belonging to preset name.
Definition: mitkRigidRegistrationPreset.cpp:153
mitk::TransformParameters::QUATERNIONRIGIDTRANSFORM
Definition: mitkTransformParameters.h:61
mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER
Definition: mitkOptimizerParameters.h:52
mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER
Definition: mitkOptimizerParameters.h:56
us::GetModuleContext
static ModuleContext * GetModuleContext()
Returns the module context of the calling module.
Definition: usGetModuleContext.h:50
mitk::TransformParameters::TRANSLATIONTRANSFORM
Definition: mitkTransformParameters.h:54
mitk::MetricParameters::KAPPASTATISTICIMAGETOIMAGEMETRIC
Definition: mitkMetricParameters.h:64
mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER
Definition: mitkOptimizerParameters.h:53
mitk::RigidRegistrationPreset::getOptimizerValues
itk::Array< double > getOptimizerValues(std::string name)
Returns an array including all all optimizer values belonging to preset name.
Definition: mitkRigidRegistrationPreset.cpp:155
mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER
Definition: mitkOptimizerParameters.h:62
mitk::OptimizerParameters::POWELLOPTIMIZER
Definition: mitkOptimizerParameters.h:57