← Back to branch summary

~ubuntu-branches/ubuntu/precise/insighttoolkit/precise

« back to all changes in this revision

Viewing changes to Code/Common/itkTransform.h

  • Committer: Bazaar Package Importer
  • Author(s): Steve M. Robbins
  • Date: 2008-12-19 20:16:49 UTC
  • mfrom: (1.2.1 upstream) (4.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20081219201649-drt97guwl2ryt0cn

* New upstream version.
  - patches/nifti-versioning.patch: Remove.  Applied upstream.
  - control:
  - rules: Update version numbers, package names.

* control: Build-depend on uuid-dev (gdcm uses it).

* copyright: Update download URL.

* rules: Adhere to parallel=N in DEB_BUILD_OPTIONS by setting MAKEFLAGS.

* compat: Set to 7.
* control: Update build-dep on debhelper to version >= 7.

* CMakeCache.txt.debian: Set CMAKE_BUILD_TYPE to "RELEASE" so that we
  build with -O3 (not -O2), necessary to optimize the templated code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Code/Common/itkTransform.h
3
3
  Program:   Insight Segmentation & Registration Toolkit
4
4
  Module:    $RCSfile: itkTransform.h,v $
5
5
  Language:  C++
6
 
  Date:      $Date: 2008-01-23 22:44:36 $
7
 
  Version:   $Revision: 1.57 $
 
6
  Date:      $Date: 2008-06-29 12:58:58 $
 
7
  Version:   $Revision: 1.64 $
8
8
 
9
9
  Copyright (c) Insight Software Consortium. All rights reserved.
10
10
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
138
138
   * \sa SetParametersByValue
139
139
   */
140
140
  virtual void SetParameters( const ParametersType & ) 
141
 
    { itkExceptionMacro( << "Subclasses should override this method" ) };
 
141
    { itkExceptionMacro( << "Subclasses should override this method" ) }
142
142
 
143
143
  /** Set the transformation parameters and update internal transformation. 
144
144
   * This method forces the transform to copy the parameters.  The
148
148
   * \sa SetParameters
149
149
   */
150
150
  virtual void SetParametersByValue ( const ParametersType & p ) 
151
 
    { this->SetParameters ( p ); };
 
151
    { this->SetParameters ( p ); }
152
152
 
153
153
  /** Get the Transformation Parameters. */
154
154
  virtual const ParametersType& GetParameters(void) const
155
 
    { itkExceptionMacro( << "Subclasses should override this method" );
156
 
      return m_Parameters; };
 
155
    { 
 
156
    itkExceptionMacro( << "Subclasses should override this method" );
 
157
    // Next line is needed to avoid errors due to: 
 
158
    // "function must return a value".
 
159
    return this->m_Parameters; 
 
160
    }
157
161
 
158
162
  /** Set the fixed parameters and update internal transformation. */
159
163
  virtual void SetFixedParameters( const ParametersType & ) 
160
 
    { itkExceptionMacro( << "Subclasses should override this method" ) };
 
164
    { itkExceptionMacro( << "Subclasses should override this method" ) }
161
165
 
162
166
  /** Get the Fixed Parameters. */
163
167
  virtual const ParametersType& GetFixedParameters(void) const
164
 
    { itkExceptionMacro( << "Subclasses should override this method" );
165
 
      return m_Parameters; };
 
168
    {
 
169
    itkExceptionMacro( << "Subclasses should override this method" );
 
170
    // Next line is needed to avoid errors due to: 
 
171
    // "function must return a value".
 
172
    return this->m_FixedParameters;
 
173
    }
166
174
 
167
175
  /** Compute the Jacobian of the transformation
168
176
   *
192
200
   * \f]
193
201
   * **/
194
202
  virtual const JacobianType & GetJacobian(const InputPointType  &) const
195
 
    { itkExceptionMacro( << "Subclass should override this method" );
196
 
      return m_Jacobian; }; 
 
203
    {
 
204
    itkExceptionMacro( << "Subclass should override this method" );
 
205
    // Next line is needed to avoid errors due to: 
 
206
    // "function must return a value".
 
207
    return this->m_Jacobian;
 
208
    } 
197
209
 
198
210
 
199
211
  /** Return the number of parameters that completely define the Transfom  */
200
212
  virtual unsigned int GetNumberOfParameters(void) const 
201
 
                      { return m_Parameters.Size(); }
 
213
                      { return this->m_Parameters.Size(); }
202
214
 
203
215
  /** Returns a boolean indicating whether it is possible or not to compute the
204
216
   * inverse of this current Transform. If it is possible, then the inverse of
205
217
   * the transform is returned in the inverseTransform variable passed by the
206
218
   * user.  The inverse is recomputed if this current transform has been modified.
207
219
   * This method is intended to be overriden by derived classes.
208
 
   * */
 
220
   * 
 
221
   */
209
222
  bool GetInverse(Self * inverseTransform) const {return false;}
210
223
 
211
224
  /** Generate a platform independant name */
229
242
protected:
230
243
  Transform(); 
231
244
  Transform(unsigned int Dimension, unsigned int NumberOfParameters);
232
 
  virtual ~Transform() {};
 
245
  virtual ~Transform() {}
233
246
 
234
247
 
235
248
  mutable ParametersType     m_Parameters;