Medical Imaging Interaction Toolkit  2016.11.0
Medical Imaging Interaction Toolkit
itkVtkAbstractTransform.txx
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 "itkVtkAbstractTransform.h"
18 #include <mitkNumericTypes.h>
19 #include <vtkAbstractTransform.h>
20 
21 namespace itk
22 {
23  template <class TScalarType>
24  itk::VtkAbstractTransform<TScalarType>::VtkAbstractTransform()
25  : m_VtkAbstractTransform(nullptr), m_InverseVtkAbstractTransform(nullptr), m_LastVtkAbstractTransformTimeStamp(0)
26  {
27  }
28 
29  template <class TScalarType>
30  itk::VtkAbstractTransform<TScalarType>::~VtkAbstractTransform()
31  {
32  if (m_VtkAbstractTransform != nullptr)
33  m_VtkAbstractTransform->UnRegister(nullptr);
34  }
35 
36  template <class TScalarType>
37  vtkAbstractTransform *itk::VtkAbstractTransform<TScalarType>::GetVtkAbstractTransform() const
38  {
39  return m_VtkAbstractTransform;
40  }
41 
42  template <class TScalarType>
43  vtkAbstractTransform *itk::VtkAbstractTransform<TScalarType>::GetInverseVtkAbstractTransform() const
44  {
45  return m_InverseVtkAbstractTransform;
46  }
47 
48  template <class TScalarType>
49  void itk::VtkAbstractTransform<TScalarType>::SetVtkAbstractTransform(vtkAbstractTransform *aVtkAbstractTransform)
50  {
51  if (m_VtkAbstractTransform == aVtkAbstractTransform)
52  return;
53 
54  if (m_VtkAbstractTransform != nullptr)
55  m_VtkAbstractTransform->UnRegister(nullptr);
56 
57  m_VtkAbstractTransform = aVtkAbstractTransform;
58  if (m_VtkAbstractTransform != nullptr)
59  {
60  m_VtkAbstractTransform->Register(nullptr);
61  m_InverseVtkAbstractTransform = m_VtkAbstractTransform->GetInverse(); // memory managed by m_VtkAbstractTransform
62  }
63 
64  m_LastVtkAbstractTransformTimeStamp = m_VtkAbstractTransform->GetMTime();
65 
66  this->Modified();
67  }
68 
69  // Transform a point
70  template <class TScalarType>
71  typename itk::VtkAbstractTransform<TScalarType>::OutputPointType
72  itk::VtkAbstractTransform<TScalarType>::TransformPoint(const InputPointType &point) const
73  {
74  assert(m_VtkAbstractTransform != nullptr);
75 
76  OutputPointType outputpoint;
77  vnl_vector<TScalarType> vnl_vec;
78  mitk::ScalarType vtkpt[3];
79  mitk::itk2vtk(point, vtkpt);
80  m_VtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
81  mitk::vtk2itk(vtkpt, outputpoint);
82  return outputpoint;
83  }
84 
85  // Transform a vector
86  template <class TScalarType>
87  typename itk::VtkAbstractTransform<TScalarType>::OutputVectorType
88  itk::VtkAbstractTransform<TScalarType>::TransformVector(const InputVectorType &vect) const
89  {
90  assert(m_VtkAbstractTransform != nullptr);
91 
92  OutputVectorType outputvector;
93  vnl_vector<TScalarType> vnl_vec;
94  mitk::ScalarType vtkpt[3] = {0, 0, 0};
95  mitk::ScalarType vtkvec[3];
96  mitk::vnl2vtk<TScalarType, mitk::ScalarType>(vect.GetVnlVector(), vtkvec);
97  m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
98  mitk::vtk2itk(vtkvec, outputvector);
99  return outputvector;
100  }
101 
102  // Transform a vnl_vector_fixed
103  template <class TScalarType>
104  typename itk::VtkAbstractTransform<TScalarType>::OutputVnlVectorType
105  itk::VtkAbstractTransform<TScalarType>::TransformVector(const InputVnlVectorType &vect) const
106  {
107  assert(m_VtkAbstractTransform != nullptr);
108 
109  OutputVnlVectorType outputvector;
110  mitk::ScalarType vtkpt[3] = {0, 0, 0};
111  mitk::ScalarType vtkvec[3];
112  mitk::vnl2vtk<TScalarType, mitk::ScalarType>(vect, vtkvec);
113  m_VtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
114  mitk::vtk2itk(vtkvec, outputvector);
115  return outputvector;
116  }
117 
118  // Transform a CovariantVector
119  template <class TScalarType>
120  typename itk::VtkAbstractTransform<TScalarType>::OutputCovariantVectorType
121  itk::VtkAbstractTransform<TScalarType>::TransformCovariantVector(const InputCovariantVectorType & /*vec*/) const
122  {
123  itkExceptionMacro(<< "implement before using!");
124  OutputCovariantVectorType result; // Converted vector
125 
126  // for (unsigned int i = 0; i < NDimensions; i++)
127  // {
128  // result[i] = NumericTraits<mitk::ScalarType>::Zero;
129  // for (unsigned int j = 0; j < NDimensions; j++)
130  // {
131  // result[i] += m_Inverse[j][i]*vec[j]; // Inverse transposed
132  // }
133  // }
134  return result;
135  }
136 
137  // Back transform a point
138  template <class TScalarType>
139  typename VtkAbstractTransform<TScalarType>::InputPointType itk::VtkAbstractTransform<TScalarType>::BackTransform(
140  const OutputPointType &point) const
141  {
142  assert(m_VtkAbstractTransform != nullptr);
143 
144  OutputPointType outputpoint;
145  mitk::ScalarType vtkpt[3];
146  mitk::itk2vtk(point, vtkpt);
147  m_InverseVtkAbstractTransform->TransformPoint(vtkpt, vtkpt);
148  mitk::vtk2itk(vtkpt, outputpoint);
149  return outputpoint;
150  }
151 
152  // Back transform a vector
153  template <class TScalarType>
154  typename VtkAbstractTransform<TScalarType>::InputVectorType itk::VtkAbstractTransform<TScalarType>::BackTransform(
155  const OutputVectorType &vect) const
156  {
157  assert(m_VtkAbstractTransform != nullptr);
158 
159  OutputVectorType outputvector;
160  mitk::ScalarType vtkpt[3] = {0, 0, 0};
161  mitk::ScalarType vtkvec[3];
162  mitk::itk2vtk(vect, vtkvec);
163  m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
164  mitk::vtk2itk(vtkvec, outputvector);
165  return outputvector;
166  }
167 
168  // Back transform a vnl_vector
169  template <class TScalarType>
170  typename VtkAbstractTransform<TScalarType>::InputVnlVectorType itk::VtkAbstractTransform<TScalarType>::BackTransform(
171  const OutputVnlVectorType &vect) const
172  {
173  assert(m_InverseVtkAbstractTransform != nullptr);
174 
175  OutputVnlVectorType outputvector;
176  mitk::ScalarType vtkpt[3] = {0, 0, 0};
177  mitk::ScalarType vtkvec[3];
178  mitk::itk2vtk(vect, vtkvec);
179  m_InverseVtkAbstractTransform->TransformVectorAtPoint(vtkpt, vtkvec, vtkvec);
180  mitk::vtk2itk(vtkvec, outputvector);
181  return outputvector;
182  }
183 
184  // Back Transform a CovariantVector
185  template <class TScalarType>
186  typename VtkAbstractTransform<TScalarType>::InputCovariantVectorType
187  itk::VtkAbstractTransform<TScalarType>::BackTransform(const OutputCovariantVectorType &vec) const
188  {
189  itkExceptionMacro(<< "implement before using!");
190  // for (unsigned int i = 0; i < NDimensions; i++)
191  // {
192  // result[i] = NumericTraits<mitk::ScalarType>::Zero;
193  // for (unsigned int j = 0; j < NDimensions; j++)
194  // {
195  // result[i] += m_Matrix[j][i]*vec[j]; // Direct matrix transposed
196  // }
197  // }
198  return vec;
199  }
200 
201  template <class TScalarType>
202  unsigned long itk::VtkAbstractTransform<TScalarType>::GetMTime() const
203  {
204  if ((m_VtkAbstractTransform != nullptr) &&
205  (m_LastVtkAbstractTransformTimeStamp < m_VtkAbstractTransform->GetMTime()))
206  {
207  m_LastVtkAbstractTransformTimeStamp = m_VtkAbstractTransform->GetMTime();
208  this->Modified();
209  }
210 
211  return Superclass::GetMTime();
212  }
213 
214  template <class TScalarType>
215  void itk::VtkAbstractTransform<TScalarType>::SetParameters(const ParametersType &)
216  {
217  // TODO
218  }
219 
220  template <class TScalarType>
221  void itk::VtkAbstractTransform<TScalarType>::SetFixedParameters(const ParametersType &)
222  {
223  // TODO
224  }
225 
226  template <class TScalarType>
227  void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToParameters(const InputPointType &,
228  JacobianType &) const
229  {
230  // TODO
231  }
232 
233  template <class TScalarType>
234  void itk::VtkAbstractTransform<TScalarType>::ComputeJacobianWithRespectToPosition(const InputPointType &,
235  JacobianType &) const
236  {
237  // TODO
238  }
239 
240 } // namespace itk