ITK  4.0.0
Insight Segmentation and Registration Toolkit
Namespaces | Defines | Functions
itkMacro.h File Reference

Go to the source code of this file.

Namespaces

namespace  itk

Defines

#define ITK_ABI_EXPORT
#define ITK_ABI_HIDDEN
#define ITK_ABI_IMPORT
#define ITK_EMPTY
#define ITK_EXPORT
#define ITK_EXPORT_ITKCommon(c, x, n)   ITK_EXPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)
#define ITK_EXPORT_TEMPLATE(EXPORT, c, x, y)   ITK_TEMPLATE_##c(ITK_TEMPLATE_EXPORT, EXPORT ITK_EMPTY, x, y)
#define ITK_IMPORT_ITKCommon(c, x, n)   ITK_IMPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)
#define ITK_IMPORT_TEMPLATE(EXPORT, c, x, y)   ITK_TEMPLATE_##c(ITK_TEMPLATE_IMPORT, EXPORT ITK_EMPTY, x, y)
#define ITK_LOCATION   "unknown"
#define ITK_TEMPLATE_1(x1)   x1
#define ITK_TEMPLATE_2(x1, x2)   x1, x2
#define ITK_TEMPLATE_3(x1, x2, x3)   x1, x2, x3
#define ITK_TEMPLATE_4(x1, x2, x3, x4)   x1, x2, x3, x4
#define ITK_TEMPLATE_5(x1, x2, x3, x4, x5)   x1, x2, x3, x4, x5
#define ITK_TEMPLATE_6(x1, x2, x3, x4, x5, x6)   x1, x2, x3, x4, x5, x6
#define ITK_TEMPLATE_7(x1, x2, x3, x4, x5, x6, x7)   x1, x2, x3, x4, x5, x6, x7
#define ITK_TEMPLATE_8(x1, x2, x3, x4, x5, x6, x7, x8)   x1, x2, x3, x4, x5, x6, x7, x8
#define ITK_TEMPLATE_9(x1, x2, x3, x4, x5, x6, x7, x8, x9)   x1, x2, x3, x4, x5, x6, x7, x8, x9
#define ITK_TEMPLATE_CXX   0
#define ITK_TEMPLATE_DO_NOT_INSTANTIATE   0
#define ITK_TEMPLATE_EXPLICIT   0
#define ITK_TEMPLATE_EXPORT(x)   ITK_TEMPLATE_EXPORT_DELAY(x)
#define ITK_TEMPLATE_EXPORT_DELAY(x)   template ITK_TEMPLATE_##x;
#define ITK_TEMPLATE_EXTERN   0
#define ITK_TEMPLATE_IMPORT(x)
#define ITK_TEMPLATE_IMPORT_WORKS   0
#define ITK_TEMPLATE_TXX   !( ITK_TEMPLATE_CXX || ITK_TEMPLATE_TYPE )
#define ITK_TEMPLATE_TYPE   0
#define itkAssertInDebugAndIgnoreInReleaseMacro(X)   assert(X)
#define itkAssertInDebugOrThrowInReleaseMacro(msg)   itkGenericExceptionMacro(<< msg);
#define itkAssertOrThrowMacro(test, message)
#define ITKCommon_EXPORT   ITK_ABI_IMPORT
#define ITKCommon_HIDDEN   ITK_ABI_HIDDEN
#define itkCreateAnotherMacro(x)
#define itkDebugStatement(x)   x
#define itkDeclareExceptionMacro(newexcp, parentexcp, whatmessage)
#define itkForLoopAssignmentMacro(DestinationType,SourceType,DestinationElementType,DestinationArray,SourceArray,NumberOfIterations)
#define itkForLoopRoundingAndAssignmentMacro(DestinationType,Sourcrnd_halfintup,DestinationElementType,DestinationArray,SourceArray,NumberOfIterations)
#define itkGenericExceptionMacro(x)
#define itkGenericLegacyBodyMacro(method, version)   itkGenericOutputMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
#define itkGenericLegacyReplaceBodyMacro(method, version, replace)
#define itkGenericOutputMacro(x)
#define itkGetConstObjectMacro(name, type)
#define itkGetConstReferenceObjectMacro(name, type)
#define itkGetObjectMacro(name, type)
#define itkGetStaticConstMacro(name)   (Self::name)
#define itkGetStringMacro(name)
#define itkGetVectorMacro(name, type, count)
#define itkLegacyBodyMacro(method, version)   itkWarningMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
#define itkLegacyMacro(method)   method
#define itkLegacyReplaceBodyMacro(method, version, replace)
#define itkLogMacro(x, y)
#define itkLogMacroStatic(obj, x, y)
#define itkNewMacro(x)
#define itkNotUsed(x)
#define itkSetGetDecoratedInputMacro(name, type)
#define itkSetGetDecoratedObjectInputMacro(name, type)
#define itkSimpleNewMacro(x)
#define itkSpecializedExceptionMacro(exceptiontype)
#define itkSpecializedMessageExceptionMacro(exceptiontype, x)
#define itkStaticConstMacro(name, type, value)   enum { name = value }
#define itkTypeMacro(thisClass, superclass)
#define itkWarningStatement(x)   x
#define itkSetInputMacro(name, type)
#define itkGetInputMacro(name, type)
#define itkSetDecoratedInputMacro(name, type)
#define itkGetDecoratedInputMacro(name, type)
#define itkSetDecoratedObjectInputMacro(name, type)
#define itkGetDecoratedObjectInputMacro(name, type)
#define itkSetMacro(name, type)
#define itkGetMacro(name, type)
#define itkGetConstMacro(name, type)
#define itkGetConstReferenceMacro(name, type)
#define itkSetEnumMacro(name, type)
#define itkGetEnumMacro(name, type)
#define itkSetStringMacro(name)
#define itkSetClampMacro(name, type, min, max)
#define itkSetObjectMacro(name, type)
#define itkSetConstObjectMacro(name, type)
#define itkBooleanMacro(name)
#define itkSetVectorMacro(name, type, count)
#define itkFactorylessNewMacro(x)
#define itkDebugMacro(x)
#define itkWarningMacro(x)
#define itkExceptionMacro(x)

Functions

ITKCommon_EXPORT void itk::OutputWindowDisplayDebugText (const char *)
ITKCommon_EXPORT void itk::OutputWindowDisplayErrorText (const char *)
ITKCommon_EXPORT void itk::OutputWindowDisplayGenericOutputText (const char *)
ITKCommon_EXPORT void itk::OutputWindowDisplayWarningText (const char *)
ITKCommon_EXPORT void itk::OutputWindowDisplayText (const char *)

Define Documentation

#define ITK_ABI_EXPORT

Definition at line 118 of file itkMacro.h.

#define ITK_ABI_HIDDEN

Definition at line 119 of file itkMacro.h.

#define ITK_ABI_IMPORT

Definition at line 117 of file itkMacro.h.

#define ITK_EMPTY

Definition at line 1015 of file itkMacro.h.

#define ITK_EXPORT

Definition at line 105 of file itkMacro.h.

#define ITK_EXPORT_ITKCommon (   c,
  x,
 
)    ITK_EXPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)

Definition at line 1064 of file itkMacro.h.

#define ITK_EXPORT_TEMPLATE (   EXPORT,
  c,
  x,
 
)    ITK_TEMPLATE_##c(ITK_TEMPLATE_EXPORT, EXPORT ITK_EMPTY, x, y)

Define macros to export and import template instantiations. These depend on each class providing a macro defining the instantiations given template arguments in X. The argument X is of the form N(a1[,a2...,aN]). The argument Y is a valid preprocessing token unique to the template arguments given in X. Typical usage is

ITK_EXPORT_TEMPLATE(itkfoo_EXPORT, Foo, (int), I) ITK_EXPORT_TEMPLATE(itkfoo_EXPORT, Bar, (int, char), IC)

The ITK_TEMPLATE_<name> macro should be defined in itk<name>.h and is of the following form:

#define ITK_TEMPLATE_<name>(_, EXPORT, TypeX, TypeY) \ namespace itk { \ _(<n>(class EXPORT <name>< ITK_TEMPLATE_<n> x >)) \ namespace Templates { \ typedef <name>< ITK_TEMPLATE_<n> x > <name>##TypeY; \ }\ }

The argument "_" will be replaced by another macro such as ITK_TEMPLATE_EXPORT or ITK_TEMPLATE_IMPORT, so it should be used as if calling one of these macros. The argument "EXPORT" will be replaced by a dllexport/dllimport macro such as ITKCommon_EXPORT. The argument "x" is a paren-enclosed list of template arguments. The argument "y" is a preprocessing token corresponding to the given template arguments and should be used to construct typedef names for the instantiations.

Note the use of ITK_TEMPLATE_<n>, where <n> is the number of template arguments for the class template. Note also that the number of template arguments is usually the length of the list nested within the inner parentheses, so the instantiation is listed with the form <n>(...). Example definitions:

#define ITK_TEMPLATE_Foo(_, EXPORT, TypeX, TypeY) \ namespace itk { \ _(1(class EXPORT Foo< ITK_TEMPLATE_1 TypeX >)) \ _(1(EXPORT std::ostream& operator<<(std::ostream&, \ const Foo< ITK_TEMPLATE_1 TypeX >&))) \ namespace Templates { \ typedef Foo< ITK_TEMPLATE_1 TypeX > Foo##TypeY; \ }\ }

#define ITK_TEMPLATE_Bar(_, EXPORT, TypeX, TypeY) \ namespace itk { \ _(2(class EXPORT Bar< ITK_TEMPLATE_2 TypeX >)) \ _(1(EXPORT std::ostream& operator<<(std::ostream&, \ const Bar< ITK_TEMPLATE_2 TypeX >&))) \ namespace Templates { \ typedef Bar< ITK_TEMPLATE_2 TypeX > Bar##TypeY; \ }\ }

Note that in the stream operator for template Bar there is a "1" at the beginning even though two arguments are taken. This is because the expression "ITK_TEMPLATE_2 TypeX" is contained inside the parentheses of the function signature which protects the resulting comma from separating macro arguments. Therefore the nested parentheses contain a list of only one macro argument.

The ITK_EMPTY macro used in these definitions is a hack to work around a VS 6.0 preprocessor bug when EXPORT is empty.

Definition at line 1011 of file itkMacro.h.

#define ITK_IMPORT_ITKCommon (   c,
  x,
 
)    ITK_IMPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)

Definition at line 1066 of file itkMacro.h.

#define ITK_IMPORT_TEMPLATE (   EXPORT,
  c,
  x,
 
)    ITK_TEMPLATE_##c(ITK_TEMPLATE_IMPORT, EXPORT ITK_EMPTY, x, y)

Definition at line 1013 of file itkMacro.h.

#define ITK_LOCATION   "unknown"
#define ITK_TEMPLATE_1 (   x1)    x1

Definition at line 1021 of file itkMacro.h.

#define ITK_TEMPLATE_2 (   x1,
  x2 
)    x1, x2

Definition at line 1022 of file itkMacro.h.

#define ITK_TEMPLATE_3 (   x1,
  x2,
  x3 
)    x1, x2, x3

Definition at line 1023 of file itkMacro.h.

#define ITK_TEMPLATE_4 (   x1,
  x2,
  x3,
  x4 
)    x1, x2, x3, x4

Definition at line 1024 of file itkMacro.h.

#define ITK_TEMPLATE_5 (   x1,
  x2,
  x3,
  x4,
  x5 
)    x1, x2, x3, x4, x5

Definition at line 1025 of file itkMacro.h.

#define ITK_TEMPLATE_6 (   x1,
  x2,
  x3,
  x4,
  x5,
  x6 
)    x1, x2, x3, x4, x5, x6

Definition at line 1026 of file itkMacro.h.

#define ITK_TEMPLATE_7 (   x1,
  x2,
  x3,
  x4,
  x5,
  x6,
  x7 
)    x1, x2, x3, x4, x5, x6, x7

Definition at line 1027 of file itkMacro.h.

#define ITK_TEMPLATE_8 (   x1,
  x2,
  x3,
  x4,
  x5,
  x6,
  x7,
  x8 
)    x1, x2, x3, x4, x5, x6, x7, x8

Definition at line 1028 of file itkMacro.h.

#define ITK_TEMPLATE_9 (   x1,
  x2,
  x3,
  x4,
  x5,
  x6,
  x7,
  x8,
  x9 
)    x1, x2, x3, x4, x5, x6, x7, x8, x9

Definition at line 1029 of file itkMacro.h.

#define ITK_TEMPLATE_CXX   0

Definition at line 1040 of file itkMacro.h.

#define ITK_TEMPLATE_DO_NOT_INSTANTIATE   0

Definition at line 907 of file itkMacro.h.

#define ITK_TEMPLATE_EXPLICIT   0

Definition at line 1085 of file itkMacro.h.

#define ITK_TEMPLATE_EXPORT (   x)    ITK_TEMPLATE_EXPORT_DELAY(x)

Definition at line 920 of file itkMacro.h.

#define ITK_TEMPLATE_EXPORT_DELAY (   x)    template ITK_TEMPLATE_##x;

Definition at line 921 of file itkMacro.h.

#define ITK_TEMPLATE_EXTERN   0

Definition at line 910 of file itkMacro.h.

#define ITK_TEMPLATE_IMPORT (   x)

Definition at line 942 of file itkMacro.h.

#define ITK_TEMPLATE_IMPORT_WORKS   0

Definition at line 943 of file itkMacro.h.

#define ITK_TEMPLATE_TXX   !( ITK_TEMPLATE_CXX || ITK_TEMPLATE_TYPE )

Definition at line 1048 of file itkMacro.h.

#define ITK_TEMPLATE_TYPE   0

Definition at line 1043 of file itkMacro.h.

#define itkAssertInDebugAndIgnoreInReleaseMacro (   X)    assert(X)
#define itkAssertInDebugOrThrowInReleaseMacro (   msg)    itkGenericExceptionMacro(<< msg);

Definition at line 1139 of file itkMacro.h.

#define itkAssertOrThrowMacro (   test,
  message 
)
Value:
if ( !( test ) )                                                 \
    {                                                              \
    std::ostringstream msgstr;                                     \
    msgstr << message;                                             \
    itkAssertInDebugOrThrowInReleaseMacro( msgstr.str().c_str() ); \
    }

Definition at line 1146 of file itkMacro.h.

Referenced by itk::CleanQuadEdgeMeshFilter< TInput, TOutput >::GenerateData(), and itk::ImageConstIterator< ImageType >::ImageConstIterator().

#define itkBooleanMacro (   name)
Value:
virtual void name##On ()  \
    {                         \
    this->Set##name(true);  \
    }                         \
  virtual void name##Off () \
    {                         \
    this->Set##name(false); \
    }

Create members "name"On() and "name"Off() (e.g., DebugOn() DebugOff()). Set method must be defined to use this macro.

Definition at line 467 of file itkMacro.h.

#define ITKCommon_EXPORT   ITK_ABI_IMPORT

Definition at line 129 of file itkMacro.h.

#define ITKCommon_HIDDEN   ITK_ABI_HIDDEN

Definition at line 123 of file itkMacro.h.

#define itkCreateAnotherMacro (   x)
Value:
virtual::itk::LightObject::Pointer CreateAnother(void) const \
    {                                                          \
    ::itk::LightObject::Pointer smartPtr;                      \
    smartPtr = x::New().GetPointer();                          \
    return smartPtr;                                           \
    }

Definition at line 547 of file itkMacro.h.

#define itkDebugMacro (   x)
Value:
{                                                                   \
    if ( this->GetDebug() && ::itk::Object::GetGlobalWarningDisplay() ) \
      {                                                                 \
      std::ostringstream itkmsg;                                        \
      itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << "\n"     \
             << this->GetNameOfClass() << " (" << this << "): " x       \
             << "\n\n";                                                 \
      ::itk::OutputWindowDisplayDebugText( itkmsg.str().c_str() );      \
      }                                                                 \
    }

This macro is used to print debug (or other information). They are also used to catch errors, etc. Example usage looks like: itkDebugMacro(<< "this is debug info" << this->SomeVariable);

Definition at line 623 of file itkMacro.h.

Referenced by itk::Function::ConvergenceMonitoringFunction< TScalar, TScalar >::AddEnergyValue(), itk::Function::ConvergenceMonitoringFunction< TScalar, TScalar >::ClearEnergyValues(), and itk::QuadEdgeMeshEulerOperatorSplitEdgeFunction< TMesh, TQEType >::Evaluate().

#define itkDebugStatement (   x)    x

Definition at line 638 of file itkMacro.h.

#define itkDeclareExceptionMacro (   newexcp,
  parentexcp,
  whatmessage 
)
Value:
namespace itk {                                                                         \
class ITK_EXPORT newexcp : public parentexcp                                            \
{                                                                                       \
public:                                                                                 \
newexcp( const char *file, unsigned int lineNumber ) :                                  \
parentexcp( file, lineNumber )                                                          \
{                                                                                       \
  this->SetDescription( whatmessage );                                                  \
}                                                                                       \
newexcp( const std::string & file, unsigned int lineNumber ) :                          \
parentexcp( file, lineNumber )                                                          \
{                                                                                       \
  this->SetDescription( whatmessage );                                                  \
}                                                                                       \
itkTypeMacro(newexcp, parentexcp);                                                      \
};                                                                                      \
}

Definition at line 697 of file itkMacro.h.

#define itkExceptionMacro (   x)
Value:
{                                                                                   \
    std::ostringstream message;                                                         \
    message << "itk::ERROR: " << this->GetNameOfClass()                                 \
            << "(" << this << "): " x;                                                  \
    ::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \
    throw e_; /* Explicit naming to work around Intel compiler bug.  */                 \
    }

The exception macro is used to print error information (i.e., usually a condition that results in program failure). Example usage looks like: itkExceptionMacro(<< "this is error info" << this->SomeVariable);

Definition at line 679 of file itkMacro.h.

Referenced by itk::VectorIndexSelectionCastImageFilter< TInputImage, TOutputImage >::BeforeThreadedGenerateData(), itk::MaskImageFilter< TInputImage, TMaskImage, TOutputImage >::CheckOutsideValue(), itk::Transform< TScalar, NDimensions, NDimensions >::ComputeJacobianWithRespectToParameters(), itk::Transform< TScalar, NDimensions, NDimensions >::ComputeJacobianWithRespectToPosition(), itk::Rigid3DPerspectiveTransform< TScalarType >::ComputeJacobianWithRespectToPosition(), itk::KernelTransform< TScalarType, NDimensions >::ComputeJacobianWithRespectToPosition(), itk::CompositeTransform< TScalar, NDimensions >::ComputeJacobianWithRespectToPosition(), itk::BSplineBaseTransform< TScalarType, NDimensions, VSplineOrder >::ComputeJacobianWithRespectToPosition(), itk::DisplacementFieldTransform< TScalar, NDimensions >::CreateAnother(), itk::CompositeTransform< TScalar, NDimensions >::CreateAnother(), itk::SimpleFilterWatcher::EndFilter(), FilterWatcher::EndFilter(), itk::BSplineKernelFunction< VSplineOrder, TRealValueType >::Evaluate(), itk::BSplineDerivativeKernelFunction< VSplineOrder, TRealValueType >::Evaluate(), itk::VectorGradientMagnitudeImageFilter< TInputImage, TRealType, TOutputImage >::EvaluateAtNeighborhood3D(), itk::ShapePriorMAPCostFunctionBase< TFeatureImage, TOutputPixel >::GetDerivative(), itk::DiffusionTensor3DReconstructionImageFilter< TReferenceImagePixelType, TGradientImagePixelType, TTensorPixelType, TMaskImageType >::GetGradientDirection(), itk::MultiphaseFiniteDifferenceImageFilter< TInputImage, TFeatureImage, TOutputImage, TFunction, unsigned int >::GetLevelSet(), itk::JensenHavrdaCharvatTsallisPointSetToPointSetMetricv4< TPointSet >::GetLocalNeighborhoodValue(), itk::JensenHavrdaCharvatTsallisPointSetToPointSetMetricv4< TPointSet >::GetLocalNeighborhoodValueAndDerivative(), itk::BSplineDeformableTransform< TScalarType, NDimensions, VSplineOrder >::GetNumberOfLocalParameters(), itk::STAPLEImageFilter< TInputImage, TOutputImage >::GetSensitivity(), itk::STAPLEImageFilter< TInputImage, TOutputImage >::GetSpecificity(), itk::HistogramThresholdCalculator< THistogram, TOutput >::GetThreshold(), itk::HilbertPath< TIndexValue, VDimension >::IncrementInput(), itk::FastMarchingReachedTargetNodesStoppingCriterion< TInput, TOutput >::Initialize(), itk::VTKPolyDataMeshIO::ReadCellDataBufferAsASCII(), itk::VTKPolyDataMeshIO::ReadCellDataBufferAsBINARY(), itk::VTKPolyDataMeshIO::ReadPointDataBufferAsASCII(), itk::VTKPolyDataMeshIO::ReadPointDataBufferAsBINARY(), itk::Testing::ExtractSliceImageFilter< TInputImage, TOutputImage >::SetDirectionCollapseToStrategy(), itk::ExtractImageFilter< TInputImage, TOutputImage >::SetDirectionCollapseToStrategy(), itk::WatershedImageFilter< TInputImage >::SetInput(), itk::GaussianOperator< ScalarType, Superclass::Dimension >::SetMaximumError(), itk::Statistics::Sample< ImageJointDomainTraits< TImage >::MeasurementVectorType >::SetMeasurementVectorSize(), itk::Statistics::MembershipFunctionBase< TMeasurementVector >::SetMeasurementVectorSize(), itk::Statistics::DistanceMetric< ParameterType >::SetMeasurementVectorSize(), itk::DisplacementFieldTransform< TScalar, NDimensions >::SetParameters(), itk::DiffusionTensor3DReconstructionImageFilter< TReferenceImagePixelType, TGradientImagePixelType, TTensorPixelType, TMaskImageType >::SetReferenceImage(), itk::LBFGSBOptimizer::SetScales(), itk::Transform< TScalar, NDimensions, NDimensions >::TransformCovariantVector(), itk::Rigid3DPerspectiveTransform< TScalarType >::TransformCovariantVector(), itk::KernelTransform< TScalarType, NDimensions >::TransformCovariantVector(), itk::DisplacementFieldTransform< TScalar, NDimensions >::TransformCovariantVector(), itk::BSplineBaseTransform< TScalarType, NDimensions, VSplineOrder >::TransformCovariantVector(), itk::DisplacementFieldTransform< TScalar, NDimensions >::TransformDiffusionTensor(), itk::Transform< TScalar, NDimensions, NDimensions >::TransformDiffusionTensor3D(), itk::Transform< TScalar, NDimensions, NDimensions >::TransformSymmetricSecondRankTensor(), itk::Transform< TScalar, NDimensions, NDimensions >::TransformVector(), itk::Rigid3DPerspectiveTransform< TScalarType >::TransformVector(), itk::KernelTransform< TScalarType, NDimensions >::TransformVector(), itk::DisplacementFieldTransform< TScalar, NDimensions >::TransformVector(), itk::BSplineBaseTransform< TScalarType, NDimensions, VSplineOrder >::TransformVector(), itk::VTKPolyDataMeshIO::UpdateCellInformation(), itk::VTKPolyDataMeshIO::WriteCellDataBufferAsASCII(), itk::VTKPolyDataMeshIO::WriteCellDataBufferAsBINARY(), itk::VTKPolyDataMeshIO::WritePointDataBufferAsASCII(), and itk::VTKPolyDataMeshIO::WritePointDataBufferAsBINARY().

#define itkFactorylessNewMacro (   x)
Value:
static Pointer New(void)                                     \
    {                                                          \
    Pointer smartPtr;                                          \
    x *     rawPtr = new x;                                    \
    smartPtr = rawPtr;                                         \
    rawPtr->UnRegister();                                      \
    return smartPtr;                                           \
    }                                                          \
  virtual::itk::LightObject::Pointer CreateAnother(void) const \
    {                                                          \
    ::itk::LightObject::Pointer smartPtr;                      \
    smartPtr = x::New().GetPointer();                          \
    return smartPtr;                                           \
    }

Define two object creation methods. The first method, New(), creates an object from a class but does not defer to a factory. The second method, CreateAnother(), creates an object from an instance, again without deferring to a factory. This second method allows you to create an instance of an object that is exactly the same type as the referring object. This is useful in cases where an object has been cast back to a base class.

These creation methods first try asking the object factory to create an instance, and then default to the standard "new" operator if the factory fails.

These routines assigns the raw pointer to a smart pointer and then call UnRegister() on the rawPtr to compensate for LightObject's constructor initializing an object's reference count to 1 (needed for proper initialization of process objects and data objects cycles).

Definition at line 571 of file itkMacro.h.

#define itkForLoopAssignmentMacro (   DestinationType,
  SourceType,
  DestinationElementType,
  DestinationArray,
  SourceArray,
  NumberOfIterations 
)
Value:
for ( unsigned int i = 0; i < NumberOfIterations; ++i )                          \
    {                                                                              \
    DestinationArray[i] = static_cast< DestinationElementType >( SourceArray[i] ); \
    }

Definition at line 1101 of file itkMacro.h.

#define itkForLoopRoundingAndAssignmentMacro (   DestinationType,
  Sourcrnd_halfintup,
  DestinationElementType,
  DestinationArray,
  SourceArray,
  NumberOfIterations 
)
Value:
for ( unsigned int i = 0; i < NumberOfIterations; ++i )                             \
    {                                                                                 \
    DestinationArray[i] = itk::Math::Round< DestinationElementType >(SourceArray[i]); \
    }

Definition at line 1121 of file itkMacro.h.

Referenced by itk::Index< itkGetStaticConstMacro(ImageDimension) >::CopyWithRound().

#define itkGenericExceptionMacro (   x)
#define itkGenericLegacyBodyMacro (   method,
  version 
)    itkGenericOutputMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")

Definition at line 832 of file itkMacro.h.

#define itkGenericLegacyReplaceBodyMacro (   method,
  version,
  replace 
)
Value:
itkGenericOutputMacro(                                                                                      \
    #method " was deprecated for ITK " #version " and will be removed in a future version.  Use " #replace \
    " instead.")

Definition at line 834 of file itkMacro.h.

#define itkGenericOutputMacro (   x)
Value:
{                                                                      \
    if ( ::itk::Object::GetGlobalWarningDisplay() )                        \
      {                                                                    \
      std::ostringstream itkmsg;                                           \
      itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n"      \
      x << "\n\n";                                                         \
      ::itk::OutputWindowDisplayGenericOutputText( itkmsg.str().c_str() ); \
      }                                                                    \
    }

Definition at line 734 of file itkMacro.h.

#define itkGetConstMacro (   name,
  type 
)
Value:
virtual type Get##name () const                                   \
    {                                                                 \
    return this->m_##name;                                          \
    }

Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); This is the "const" form of the itkGetMacro. It should be used unless the member can be changed through the "Get" access routine.

Definition at line 316 of file itkMacro.h.

#define itkGetConstObjectMacro (   name,
  type 
)
Value:
virtual const type * Get##name () const                             \
    {                                                                   \
    return this->m_##name.GetPointer();                               \
    }

Get a smart const pointer to an object. Creates the member Get"name"() (e.g., GetPoints()).

Definition at line 451 of file itkMacro.h.

#define itkGetConstReferenceMacro (   name,
  type 
)
Value:
virtual const type &Get##name () const                            \
    {                                                                 \
    return this->m_##name;                                          \
    }

Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); This is the "const" form of the itkGetMacro. It should be used unless the member can be changed through the "Get" access routine. This versions returns a const reference to the variable.

Definition at line 327 of file itkMacro.h.

#define itkGetConstReferenceObjectMacro (   name,
  type 
)
Value:
virtual const typename type::Pointer & Get##name () const             \
    {                                                                   \
    return this->m_##name;                                              \
    }

Get a const reference to a smart pointer to an object. Creates the member Get"name"() (e.g., GetPoints()).

Definition at line 459 of file itkMacro.h.

#define itkGetDecoratedInputMacro (   name,
  type 
)
Value:
virtual const SimpleDataObjectDecorator< type > * Get##name##Input() const                                                                 \
    {                                                                                                                                        \
    itkDebugMacro( "returning input " << #name " of "                                                                                        \
                                      << static_cast< const SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ); \
    return static_cast< const SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) );                                 \
    }                                                                \
  virtual const type & Get##name() const                             \
    {                                                                \
    itkDebugMacro("Getting input " #name);                           \
    typedef SimpleDataObjectDecorator< type > DecoratorType;         \
    const DecoratorType *input =                                     \
      static_cast< const DecoratorType * >(                          \
        this->ProcessObject::GetInput(#name) );                      \
    if( input == NULL )                                              \
      {                                                              \
      itkExceptionMacro(<<"input" #name " is not set");              \
      }                                                              \
    return input->Get();                                             \
    }

Set a decorated input. This defines the Set"name"() and Set"name"Input() method

Definition at line 201 of file itkMacro.h.

#define itkGetDecoratedObjectInputMacro (   name,
  type 
)
Value:
virtual const DataObjectDecorator< type > * Get##name##Input() const                                                                 \
    {                                                                                                                                  \
    itkDebugMacro( "returning input " << #name " of "                                                                                  \
                                      << static_cast< const DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ); \
    return static_cast< const DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) );                                 \
    }                                                                \
  virtual const type * Get##name() const                             \
    {                                                                \
    itkDebugMacro("Getting input " #name);                           \
    typedef DataObjectDecorator< type > DecoratorType;               \
    const DecoratorType *input =                                     \
      static_cast< const DecoratorType * >(                          \
        this->ProcessObject::GetInput(#name) );                      \
    if( input == NULL )                                              \
      {                                                              \
      itkExceptionMacro(<<"input" #name " is not set");              \
      }                                                              \
    return input->Get();                                             \
    }

Get a decorated input that derives from itk::Object, but not from itk::DataObject. This defines the Get"name"() and Get"name"Input methods.

Definition at line 264 of file itkMacro.h.

#define itkGetEnumMacro (   name,
  type 
)
Value:
virtual type Get##name () const                                             \
    {                                                                         \
    return this->m_##name;                                                    \
    }

Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); This should be use when the type is an enum. It is use to avoid warnings on some compilers with non specified enum types passed to itkDebugMacro.

Definition at line 354 of file itkMacro.h.

#define itkGetInputMacro (   name,
  type 
)
Value:
virtual const type * Get##name() const                                                                        \
    {                                                                                                           \
    itkDebugMacro( "returning input " << #name " of "                                                           \
                                      << static_cast< const type * >( this->ProcessObject::GetInput(#name) ) ); \
    return static_cast< const type * >( this->ProcessObject::GetInput(#name) );                                 \
    }

Get an input. This defines the Get"name"() method

Definition at line 163 of file itkMacro.h.

#define itkGetMacro (   name,
  type 
)
Value:
virtual type Get##name ()                                         \
    {                                                                 \
    return this->m_##name;                                          \
    }

Get built-in type. Creates member Get"name"() (e.g., GetVisibility());

Definition at line 306 of file itkMacro.h.

#define itkGetObjectMacro (   name,
  type 
)
Value:
virtual type * Get##name ()                                         \
    {                                                                   \
    return this->m_##name.GetPointer();                               \
    }

Get a smart pointer to an object. Creates the member Get"name"() (e.g., GetPoints()).

Definition at line 427 of file itkMacro.h.

#define itkGetStaticConstMacro (   name)    (Self::name)
#define itkGetStringMacro (   name)
Value:
virtual const char *Get##name () const \
    {                                      \
    return this->m_##name.c_str();       \
    }

Get character string. Creates member Get"name"() (e.g., SetFilename(char *)). The macro assumes that the class member (name) is declared as a type std::string.

Definition at line 388 of file itkMacro.h.

#define itkGetVectorMacro (   name,
  type,
  count 
)
Value:
virtual type * Get##name () const        \
    {                                        \
    return this->m_##name;                 \
    }

Get vector macro. Returns pointer to type (i.e., array of type). This is for efficiency.

Definition at line 505 of file itkMacro.h.

#define itkLegacyBodyMacro (   method,
  version 
)    itkWarningMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")

Definition at line 826 of file itkMacro.h.

#define itkLegacyMacro (   method)    method

Definition at line 803 of file itkMacro.h.

#define itkLegacyReplaceBodyMacro (   method,
  version,
  replace 
)
Value:
itkWarningMacro(                                                                                            \
    #method " was deprecated for ITK " #version " and will be removed in a future version.  Use " #replace \
    " instead.")

Definition at line 828 of file itkMacro.h.

#define itkLogMacro (   x,
 
)
Value:
{                                                    \
    if ( this->GetLogger() )                             \
      {                                                  \
      this->GetLogger()->Write(::itk::LoggerBase::x, y); \
      }                                                  \
    }

Definition at line 748 of file itkMacro.h.

#define itkLogMacroStatic (   obj,
  x,
 
)
Value:
{                                                   \
    if ( obj->GetLogger() )                             \
      {                                                 \
      obj->GetLogger()->Write(::itk::LoggerBase::x, y); \
      }                                                 \
    }

Definition at line 756 of file itkMacro.h.

#define itkNewMacro (   x)
Value:

Define two object creation methods. The first method, New(), creates an object from a class, potentially deferring to a factory. The second method, CreateAnother(), creates an object from an instance, potentially deferring to a factory. This second method allows you to create an instance of an object that is exactly the same type as the referring object. This is useful in cases where an object has been cast back to a base class.

These creation methods first try asking the object factory to create an instance, and then default to the standard "new" operator if the factory fails.

These routines assigns the raw pointer to a smart pointer and then call UnRegister() on the rawPtr to compensate for LightObject's constructor initializing an object's reference count to 1 (needed for proper initialization of process objects and data objects cycles).

Break the methods into itkSimpleNewMacro and itkCreateAnotherMacro so we can selectively overload CreateAnother() without having to provide a definition for New().

Definition at line 531 of file itkMacro.h.

#define itkNotUsed (   x)

A convenience macro marks variables as not being used by a method, avoiding compile-time warnings.

Definition at line 63 of file itkMacro.h.

#define itkSetClampMacro (   name,
  type,
  min,
  max 
)
Value:
virtual void Set##name (type _arg)                                            \
    {                                                                             \
    itkDebugMacro("setting " << #name " to " << _arg);                           \
    if ( this->m_##name != ( _arg < min ? min : ( _arg > max ? max : _arg ) ) ) \
      {                                                                           \
      this->m_##name = ( _arg < min ? min : ( _arg > max ? max : _arg ) );      \
      this->Modified();                                                           \
      }                                                                           \
    }

Set built-in type where value is constrained between min/max limits. Create member Set"name"() (e.q., SetRadius()). #defines are convienience for clamping open-ended values.

Definition at line 397 of file itkMacro.h.

#define itkSetConstObjectMacro (   name,
  type 
)
Value:
virtual void Set##name (const type * _arg)          \
    {                                                   \
    itkDebugMacro("setting " << #name " to " << _arg); \
    if ( this->m_##name != _arg )                     \
      {                                                 \
      this->m_##name = _arg;                          \
      this->Modified();                                 \
      }                                                 \
    }

Set const pointer to object; uses Object reference counting methodology. Creates method Set"name"() (e.g., SetPoints()). Note that using smart pointers requires using real pointers when setting input, but returning smart pointers on output.

Definition at line 437 of file itkMacro.h.

#define itkSetDecoratedInputMacro (   name,
  type 
)
Value:
virtual void Set##name##Input(const SimpleDataObjectDecorator< type > *_arg)                                \
    {                                                                                                         \
    itkDebugMacro("setting input " #name " to " << _arg);                                                     \
    if ( _arg != static_cast< SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ) \
      {                                                                                                       \
      this->ProcessObject::SetInput( #name, const_cast< SimpleDataObjectDecorator< type > * >( _arg ) );      \
      this->Modified();                                                                                       \
      }                                                                                                       \
    }                                                                                                         \
  virtual void Set##name(const type &_arg)                           \
    {                                                                \
    typedef SimpleDataObjectDecorator< type > DecoratorType;         \
    itkDebugMacro("setting input " #name " to " << _arg);            \
    const DecoratorType *oldInput =                                  \
      static_cast< const DecoratorType * >(                          \
        this->ProcessObject::GetInput(#name) );                      \
    if ( oldInput && oldInput->Get() == _arg )                       \
      {                                                              \
      return;                                                        \
      }                                                              \
    typename DecoratorType::Pointer newInput = DecoratorType::New(); \
    newInput->Set(_arg);                                             \
    this->Set##name##Input(newInput);                                \
    }

Set a decorated input. This defines the Set"name"() and a Set"name"Input() method

Definition at line 173 of file itkMacro.h.

#define itkSetDecoratedObjectInputMacro (   name,
  type 
)
Value:
virtual void Set##name##Input(const DataObjectDecorator< type > *_arg)                                \
    {                                                                                                   \
    itkDebugMacro("setting input " #name " to " << _arg);                                               \
    if ( _arg != static_cast< DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ) \
      {                                                                                                 \
      this->ProcessObject::SetInput( #name, const_cast< DataObjectDecorator< type > * >( _arg ) );      \
      this->Modified();                                                                                 \
      }                                                                                                 \
    }                                                                                                   \
  virtual void Set##name(const type * _arg)                          \
    {                                                                \
    typedef DataObjectDecorator< type > DecoratorType;               \
    itkDebugMacro("setting input " #name " to " << _arg);            \
    const DecoratorType *oldInput =                                  \
      static_cast< const DecoratorType * >(                          \
        this->ProcessObject::GetInput(#name) );                      \
    if ( oldInput && oldInput->Get() == _arg )                       \
      {                                                              \
      return;                                                        \
      }                                                              \
    typename DecoratorType::Pointer newInput = DecoratorType::New(); \
    newInput->Set(_arg);                                             \
    this->Set##name##Input(newInput);                                \
    }

Set a decorated input that derives from itk::Object, but not from itk::DataObject. This defines the Set"name"() and Set"name"Input methods.

Definition at line 233 of file itkMacro.h.

#define itkSetEnumMacro (   name,
  type 
)
Value:
virtual void Set##name (const type _arg)                                  \
    {                                                                         \
    itkDebugMacro( "setting " #name " to " << static_cast< long >( _arg ) ); \
    if ( this->m_##name != _arg )                                           \
      {                                                                       \
      this->m_##name = _arg;                                                \
      this->Modified();                                                       \
      }                                                                       \
    }

Set built-in type. Creates member Set"name"() (e.g., SetVisibility()); This should be use when the type is an enum. It is use to avoid warnings on some compilers with non specified enum types passed to itkDebugMacro.

Definition at line 338 of file itkMacro.h.

#define itkSetGetDecoratedInputMacro (   name,
  type 
)
Value:

Set a decorated input. This defines the Set"name"() and Set"name"Input() method and Get"name" and Get"name"Input methods

Definition at line 225 of file itkMacro.h.

#define itkSetGetDecoratedObjectInputMacro (   name,
  type 
)
Value:

Set a decorated input. This defines the Set"name"() and Set"name"Input() method and Get"name" and Get"name"Input methods

Definition at line 288 of file itkMacro.h.

#define itkSetInputMacro (   name,
  type 
)
Value:
virtual void Set##name(const type *_arg)                                        \
    {                                                                             \
    itkDebugMacro("setting input " #name " to " << _arg);                         \
    if ( _arg != static_cast< type * >( this->ProcessObject::GetInput(#name) ) )  \
      {                                                                           \
      this->ProcessObject::SetInput( #name, const_cast< type * >( _arg ) );       \
      this->Modified();                                                           \
      }                                                                           \
    }

Set an input. This defines the Set"name"() method

Definition at line 150 of file itkMacro.h.

#define itkSetMacro (   name,
  type 
)
Value:
virtual void Set##name (const type _arg)         \
    {                                                \
    itkDebugMacro("setting " #name " to " << _arg); \
    if ( this->m_##name != _arg )                  \
      {                                              \
      this->m_##name = _arg;                       \
      this->Modified();                              \
      }                                              \
    }

Set built-in type. Creates member Set"name"() (e.g., SetVisibility());

Definition at line 293 of file itkMacro.h.

#define itkSetObjectMacro (   name,
  type 
)
Value:
virtual void Set##name (type * _arg)                \
    {                                                   \
    itkDebugMacro("setting " << #name " to " << _arg); \
    if ( this->m_##name != _arg )                     \
      {                                                 \
      this->m_##name = _arg;                          \
      this->Modified();                                 \
      }                                                 \
    }

Set pointer to object; uses Object reference counting methodology. Creates method Set"name"() (e.g., SetPoints()). Note that using smart pointers requires using real pointers when setting input, but returning smart pointers on output.

Definition at line 413 of file itkMacro.h.

#define itkSetStringMacro (   name)
Value:
virtual void Set##name (const char *_arg)               \
    {                                                       \
    if ( _arg && ( _arg == this->m_##name ) ) { return; } \
    if ( _arg )                                             \
      {                                                     \
      this->m_##name = _arg;                              \
      }                                                     \
    else                                                    \
      {                                                     \
      this->m_##name = "";                                \
      }                                                     \
    this->Modified();                                       \
    }                                                       \
  virtual void Set##name (const std::string & _arg)       \
    {                                                       \
    this->Set##name( _arg.c_str() );                      \
    }                                                       \

Set character string. Creates member Set"name"() (e.g., SetFilename(char *)). The macro assumes that the class member (name) is declared a type std::string.

Definition at line 364 of file itkMacro.h.

#define itkSetVectorMacro (   name,
  type,
  count 
)
Value:
virtual void Set##name(type data[])      \
    {                                        \
    unsigned int i;                          \
    for ( i = 0; i < count; i++ )            \
      {                                      \
      if ( data[i] != this->m_##name[i] )  \
        {                                    \
        break;                               \
        }                                    \
      }                                      \
    if ( i < count )                         \
      {                                      \
      this->Modified();                      \
      for ( i = 0; i < count; i++ )          \
        {                                    \
        this->m_##name[i] = data[i];       \
        }                                    \
      }                                      \
    }

General set vector macro creates a single method that copies specified number of values into object. Examples: void SetColor(c,3)

Definition at line 481 of file itkMacro.h.

#define itkSimpleNewMacro (   x)
Value:
static Pointer New(void)                                     \
    {                                                          \
    Pointer smartPtr = ::itk::ObjectFactory< x >::Create();    \
    if ( smartPtr.GetPointer() == NULL )                       \
      {                                                        \
      smartPtr = new x;                                        \
      }                                                        \
    smartPtr->UnRegister();                                    \
    return smartPtr;                                           \
    }

Definition at line 535 of file itkMacro.h.

#define itkSpecializedExceptionMacro (   exceptiontype)
Value:
{                                                                                   \
    ::itk::exceptiontype e_(__FILE__, __LINE__);                                        \
    e_.SetLocation(ITK_LOCATION);                                                       \
    throw e_; /* Explicit naming to work around Intel compiler bug.  */                 \
    }

Definition at line 716 of file itkMacro.h.

#define itkSpecializedMessageExceptionMacro (   exceptiontype,
 
)
Value:
{                                                                                   \
    ::itk::exceptiontype e_(__FILE__, __LINE__);                                        \
    std::ostringstream message;                                                         \
    message << "itk::ERROR: " x;                                                        \
    e_.SetDescription(message.str().c_str());                                           \
    e_.SetLocation(ITK_LOCATION);                                                       \
    throw e_; /* Explicit naming to work around Intel compiler bug.  */                 \
    }

Definition at line 723 of file itkMacro.h.

#define itkStaticConstMacro (   name,
  type,
  value 
)    enum { name = value }

Definition at line 145 of file itkMacro.h.

#define itkTypeMacro (   thisClass,
  superclass 
)
Value:
virtual const char *GetNameOfClass() const \
    {                                        \
    return #thisClass;                      \
    }

Macro used to add standard methods to all classes, mainly type information.

Definition at line 590 of file itkMacro.h.

#define itkWarningMacro (   x)
Value:
{                                                                 \
    if ( ::itk::Object::GetGlobalWarningDisplay() )                   \
      {                                                               \
      std::ostringstream itkmsg;                                      \
      itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" \
             << this->GetNameOfClass() << " (" << this << "): " x     \
             << "\n\n";                                               \
      ::itk::OutputWindowDisplayWarningText( itkmsg.str().c_str() );  \
      }                                                               \
    }

This macro is used to print warning information (i.e., unusual circumstance but not necessarily fatal.) Example usage looks like: itkWarningMacro(<< "this is warning info" << this->SomeVariable);

Definition at line 644 of file itkMacro.h.

Referenced by itk::Rigid2DTransform< TScalarType >::BackTransform(), itk::AffineTransform< TScalarType, NDimensions >::BackTransform(), itk::PointBasedSpatialObject< TDimension >::ComputeLocalBoundingBox(), itk::DicomImageIO::DicomImageIO(), itk::MatchCardinalityImageToImageMetric< TFixedImage, TMovingImage >::GetDerivative(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::GetMaximumIterations(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::GetMaximumIterations(), itk::AntiAliasBinaryImageFilter< TInputImage, TOutputImage >::GetMaximumIterations(), itk::PointBasedSpatialObject< TDimension >::GetNumberOfPoints(), itk::PointBasedSpatialObject< TDimension >::GetPoint(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::GetUseNegativeFeatures(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::GetUseNegativeFeatures(), itk::VectorCurvatureAnisotropicDiffusionImageFilter< TInputImage, TOutputImage >::InitializeIteration(), itk::CurvatureAnisotropicDiffusionImageFilter< TInputImage, TOutputImage >::InitializeIteration(), itk::ImageSpatialObject< TDimension, unsigned char >::InternalSetPixelType(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::SetMaximumIterations(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::SetMaximumIterations(), itk::AntiAliasBinaryImageFilter< TInputImage, TOutputImage >::SetMaximumIterations(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::SetMaximumRMSError(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::SetUseNegativeFeatures(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::SetUseNegativeFeatures(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::SetUseNegativeFeaturesOff(), itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::SetUseNegativeFeaturesOff(), itk::SegmentationLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType >::SetUseNegativeFeaturesOn(), and itk::NarrowBandLevelSetImageFilter< TInputImage, TFeatureImage, TOutputPixelType, Image< TOutputPixelType,::itk::GetImageDimension< TInputImage >::ImageDimension > >::SetUseNegativeFeaturesOn().

#define itkWarningStatement (   x)    x

Definition at line 659 of file itkMacro.h.