/usr/include/ITK-4.5/itkTimeVaryingBSplineVelocityFieldTransformParametersAdaptor.h is in libinsighttoolkit4-dev 4.5.0-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 | /*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef __itkTimeVaryingBSplineVelocityFieldTransformParametersAdaptor_h
#define __itkTimeVaryingBSplineVelocityFieldTransformParametersAdaptor_h
#include "itkTransformParametersAdaptor.h"
namespace itk
{
/** \class TimeVaryingBSplineVelocityFieldTransformParametersAdaptor
* \brief TimeVaryingBSplineVelocityFieldTransformParametersAdaptor is a helper class intended to
* definition.
*
* The fixed parameters store the following information:
* \li B-spline mesh size
* \li field origin
* \li domain spacing
* \li domain size (note that domain_spacing * (domain_size - 1) = physical dimensions of transform domain)
* \li field direction
* During multiresolution image registration it is often desired to also increase
* the displacement field resolution for greater flexibility in optimizing the
* transform. As defined in the base class, the user can change the resolution via
*
* \code
* transformAdaptor->SetTransform( transform );
* transformAdaptor->SetRequiredFixedParameters( fixedParameters );
* transformAdaptor->AdaptTransformParameters();
* \endcode
*
* or the user can use the more intuitive API for setting the fixed parameters.
* E.g., often the user will want to maintain the same transform domain spatial
* extent but only increase the field size and decrease the spacing. This can
* be done as follows:
*
* \code
* transformAdaptor->SetRequiredTransformDomainOrigin( displacementField->GetOrigin() );
* transformAdaptor->SetRequiredTransformDomainDirection( displacementField->GetDirection() );
* transformAdaptor->SetRequiredTransformDomainSize( requiredSize );
* transformAdaptor->SetRequiredTransformDomainSpacing( requiredSpacing );
* transformAdaptor->SetRequiredTransformDomainMeshSize( requiredMeshSize );
* transformAdaptor->SetSplineOrder( transform->GetSplineOrder() );
* transformAdaptor->AdaptTransformParameters();
* \endcode
*
* \author Nick Tustison
* \author Brian Avants
*
* \ingroup ITKRegistrationCommon
*/
template<typename TTransform>
class TimeVaryingBSplineVelocityFieldTransformParametersAdaptor
: public TransformParametersAdaptor<TTransform>
{
public:
/** Standard class typedefs. */
typedef TimeVaryingBSplineVelocityFieldTransformParametersAdaptor Self;
typedef TransformParametersAdaptor<TTransform> Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through a Smart Pointer. */
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( TimeVaryingBSplineVelocityFieldTransformParametersAdaptor, TransformParametersAdaptor );
/** Typedefs associated with the transform */
typedef TTransform TransformType;
typedef typename TransformType::Pointer TransformPointer;
typedef typename TransformType::ParametersType ParametersType;
typedef typename TransformType::ParametersValueType ParametersValueType;
typedef ParametersValueType RealType;
typedef typename TransformType::TimeVaryingVelocityFieldControlPointLatticeType TimeVaryingVelocityFieldControlPointLatticeType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::Pointer TimeVaryingVelocityFieldControlPointLatticePointer;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::RegionType RegionType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::IndexType IndexType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::PixelType VectorType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::PointType OriginType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::SpacingType SpacingType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::SizeType SizeType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::SizeValueType SizeValueType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::SizeType MeshSizeType;
typedef typename TimeVaryingVelocityFieldControlPointLatticeType::DirectionType DirectionType;
/** Dimension of parameters. */
itkStaticConstMacro( TotalDimension, unsigned int, TransformType::Dimension + 1 );
/** Set spline order (usually from transform) */
itkSetMacro( SplineOrder, SizeValueType );
/** Get spline order (usually from transform) */
itkGetConstMacro( SplineOrder, SizeValueType );
/** Alternative method for setting the required mesh size. */
void SetRequiredTransformDomainMeshSize( const MeshSizeType & );
/** Get the required mesh size. */
itkGetConstReferenceMacro( RequiredTransformDomainMeshSize, MeshSizeType );
/** Alternative method for setting the required sampled size. */
void SetRequiredTransformDomainSize( const SizeType & );
/** Get the required domain size. */
itkGetConstReferenceMacro( RequiredTransformDomainSize, SizeType );
/** Alternative method for setting the required sampled spacing. */
void SetRequiredTransformDomainSpacing( const SpacingType & );
/** Get the required domain spacing. */
itkGetConstReferenceMacro( RequiredTransformDomainSpacing, SpacingType );
/** Alternative method for setting the required origin. */
void SetRequiredTransformDomainOrigin( const OriginType & );
/** Get the required origin. */
itkGetConstReferenceMacro( RequiredTransformDomainOrigin, OriginType );
/** Alternative method for setting the required direction. */
void SetRequiredTransformDomainDirection( const DirectionType & );
/** Get the required direction. */
itkGetConstReferenceMacro( RequiredTransformDomainDirection, DirectionType );
/** Get the required control point lattice origin. */
const OriginType GetRequiredControlPointLatticeOrigin() const
{
OriginType requiredLatticeOrigin;
for( SizeValueType i = 0; i < TotalDimension; i++ )
{
requiredLatticeOrigin[i] = this->m_RequiredFixedParameters[TotalDimension + i];
}
return requiredLatticeOrigin;
}
/** Get the required control point lattice spacing. */
const SpacingType GetRequiredControlPointLatticeSpacing() const
{
SpacingType requiredLatticeSpacing;
for( SizeValueType i = 0; i < TotalDimension; i++ )
{
RealType domainPhysicalDimensions = static_cast<RealType>( this->m_RequiredTransformDomainSize[i] - 1.0 ) *
this->m_RequiredTransformDomainSpacing[i];
requiredLatticeSpacing[i] = domainPhysicalDimensions / static_cast<RealType>( this->m_RequiredTransformDomainMeshSize[i] );
}
return requiredLatticeSpacing;
}
/** Get the required control point lattice size. */
const SizeType GetRequiredControlPointLatticeSize() const
{
SizeType requiredLatticeSize;
for( SizeValueType i = 0; i < TotalDimension; i++ )
{
requiredLatticeSize[i] = static_cast<SizeValueType>( this->m_RequiredFixedParameters[i] );
}
return requiredLatticeSize;
}
/** Get the required control point lattice direction. */
const DirectionType GetRequiredControlPointLatticeDirection() const
{
return this->m_RequiredTransformDomainDirection;
}
/** Initialize the transform using the specified fixed parameters */
virtual void AdaptTransformParameters();
virtual void SetRequiredFixedParameters( const ParametersType );
protected:
TimeVaryingBSplineVelocityFieldTransformParametersAdaptor();
~TimeVaryingBSplineVelocityFieldTransformParametersAdaptor();
void PrintSelf( std::ostream& os, Indent indent ) const;
private:
TimeVaryingBSplineVelocityFieldTransformParametersAdaptor( const Self & ); //purposely not implemented
void operator=( const Self & ); //purposely not implemented
/** Helper function to set m_RequiredFixedParameters */
void UpdateRequiredFixedParameters();
MeshSizeType m_RequiredTransformDomainMeshSize;
OriginType m_RequiredTransformDomainOrigin;
DirectionType m_RequiredTransformDomainDirection;
SpacingType m_RequiredTransformDomainSpacing;
SizeType m_RequiredTransformDomainSize;
SizeValueType m_SplineOrder;
}; //class TimeVaryingBSplineVelocityFieldTransformParametersAdaptor
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTimeVaryingBSplineVelocityFieldTransformParametersAdaptor.hxx"
#endif
#endif /* __itkTimeVaryingBSplineVelocityFieldTransformParametersAdaptor_h */
|