From a61433a1ea32ea58e55edaa60c630b93562e7e46 Mon Sep 17 00:00:00 2001 From: "Hans J. Johnson" Date: Mon, 13 Apr 2026 05:51:01 -0500 Subject: [PATCH 1/4] STYLE: Modernize source from unmerged branches Cherry-picked and squashed from Hans Johnson's unmerged branches: - af03b1f STYLE: Add itkVirtualGetNameOfClassMacro + itkOverrideGetNameOfClassMacro - f889ad3 STYLE: Replace itkStaticConstMacro with static constexpr - 559674c STYLE: CoordRepType -> CoordinateType code readability - 53b0943 COMP: Remove inclusion of .hxx files as headers - d1aa10d STYLE: Prefer itk::Math::abs for consistency Co-Authored-By: Hans J. Johnson --- include/itkContinuousBorderWarpImageFilter.h | 2 +- include/itkContinuousBorderWarpImageFilter.hxx | 1 - include/itkVariationalDiffeomorphicRegistrationFilter.h | 2 +- .../itkVariationalDiffeomorphicRegistrationFilter.hxx | 1 - include/itkVariationalRegistrationCurvatureRegularizer.h | 2 +- include/itkVariationalRegistrationDemonsFunction.h | 2 +- include/itkVariationalRegistrationDemonsFunction.hxx | 1 - include/itkVariationalRegistrationDiffusionRegularizer.h | 2 +- .../itkVariationalRegistrationDiffusionRegularizer.hxx | 1 - include/itkVariationalRegistrationElasticRegularizer.h | 2 +- include/itkVariationalRegistrationElasticRegularizer.hxx | 4 ++-- include/itkVariationalRegistrationFastNCCFunction.h | 2 +- include/itkVariationalRegistrationFastNCCFunction.hxx | 1 - include/itkVariationalRegistrationFilter.h | 2 +- include/itkVariationalRegistrationFilter.hxx | 1 - include/itkVariationalRegistrationFunction.h | 2 +- include/itkVariationalRegistrationFunction.hxx | 1 - include/itkVariationalRegistrationGaussianRegularizer.h | 2 +- .../itkVariationalRegistrationGaussianRegularizer.hxx | 1 - include/itkVariationalRegistrationLogger.hxx | 1 - .../itkVariationalRegistrationMultiResolutionFilter.h | 4 ++-- .../itkVariationalRegistrationMultiResolutionFilter.hxx | 1 - include/itkVariationalRegistrationNCCFunction.h | 2 +- include/itkVariationalRegistrationNCCFunction.hxx | 1 - include/itkVariationalRegistrationRegularizer.h | 2 +- include/itkVariationalRegistrationRegularizer.hxx | 1 - include/itkVariationalRegistrationSSDFunction.h | 2 +- include/itkVariationalRegistrationSSDFunction.hxx | 1 - include/itkVariationalRegistrationStopCriterion.hxx | 9 ++++----- ...VariationalSymmetricDiffeomorphicRegistrationFilter.h | 2 +- ...riationalSymmetricDiffeomorphicRegistrationFilter.hxx | 1 - test/VariationalRegistrationFilterTest.cxx | 4 ++-- .../VariationalRegistrationMultiResolutionFilterTest.cxx | 4 ++-- 33 files changed, 26 insertions(+), 41 deletions(-) diff --git a/include/itkContinuousBorderWarpImageFilter.h b/include/itkContinuousBorderWarpImageFilter.h index b455565..2db76c2 100644 --- a/include/itkContinuousBorderWarpImageFilter.h +++ b/include/itkContinuousBorderWarpImageFilter.h @@ -71,7 +71,7 @@ class ContinuousBorderWarpImageFilter : public WarpImageFilter::ThreadedSolveElas detD = d11 * d22 * d33 - d11 * d23 * d23 - d12 * d12 * d33 + d12 * d13 * d23 + d12 * d13 * d23 - d13 * d13 * d22; // Calculate the inverse values - if (fabs(detD) < 1e-15) + if (itk::Math::abs(detD) < 1e-15) { // If determinant is (close to) zero, inverse is zero m_ComplexBuffer[0][i][0] = 0; @@ -552,7 +552,7 @@ VariationalRegistrationElasticRegularizer::ThreadedSolveElas detD = d11 * d22 - d12 * d12; // Calculate the inverse values - if (fabs(detD) < 1e-15) + if (itk::Math::abs(detD) < 1e-15) { // If determinant is (close to) zero, inverse is zero m_ComplexBuffer[0][i][0] = 0; diff --git a/include/itkVariationalRegistrationFastNCCFunction.h b/include/itkVariationalRegistrationFastNCCFunction.h index 6dbade0..a92e2b5 100644 --- a/include/itkVariationalRegistrationFastNCCFunction.h +++ b/include/itkVariationalRegistrationFastNCCFunction.h @@ -79,7 +79,7 @@ class VariationalRegistrationFastNCCFunction itkNewMacro(Self); /** Run-time type information (and related methods). */ - itkTypeMacro(VariationalRegistrationFastNCCFunction, VariationalRegistrationNCCFunction); + itkOverrideGetNameOfClassMacro(VariationalRegistrationFastNCCFunction); /** Get image dimension. */ static constexpr unsigned int ImageDimension = Superclass::ImageDimension; diff --git a/include/itkVariationalRegistrationFastNCCFunction.hxx b/include/itkVariationalRegistrationFastNCCFunction.hxx index 95b6c11..18caeb8 100644 --- a/include/itkVariationalRegistrationFastNCCFunction.hxx +++ b/include/itkVariationalRegistrationFastNCCFunction.hxx @@ -18,7 +18,6 @@ #ifndef itkVariationalRegistrationFastNCCFunction_hxx #define itkVariationalRegistrationFastNCCFunction_hxx -#include "itkVariationalRegistrationFastNCCFunction.h" #include "itkMacro.h" #include "itkMath.h" diff --git a/include/itkVariationalRegistrationFilter.h b/include/itkVariationalRegistrationFilter.h index 78eead8..f2b0ccb 100644 --- a/include/itkVariationalRegistrationFilter.h +++ b/include/itkVariationalRegistrationFilter.h @@ -111,7 +111,7 @@ class VariationalRegistrationFilter : public DenseFiniteDifferenceImageFilter; + using FloatImageType = Image; /** The internal registration type. */ using RegistrationType = VariationalRegistrationFilter; diff --git a/include/itkVariationalRegistrationMultiResolutionFilter.hxx b/include/itkVariationalRegistrationMultiResolutionFilter.hxx index 75f26bc..845ea40 100644 --- a/include/itkVariationalRegistrationMultiResolutionFilter.hxx +++ b/include/itkVariationalRegistrationMultiResolutionFilter.hxx @@ -17,7 +17,6 @@ *=========================================================================*/ #ifndef itkVariationalRegistrationMultiResolutionFilter_hxx #define itkVariationalRegistrationMultiResolutionFilter_hxx -#include "itkVariationalRegistrationMultiResolutionFilter.h" #include "itkRecursiveGaussianImageFilter.h" #include "itkMinimumMaximumImageCalculator.h" diff --git a/include/itkVariationalRegistrationNCCFunction.h b/include/itkVariationalRegistrationNCCFunction.h index 5006720..14506d7 100644 --- a/include/itkVariationalRegistrationNCCFunction.h +++ b/include/itkVariationalRegistrationNCCFunction.h @@ -78,7 +78,7 @@ class VariationalRegistrationNCCFunction itkNewMacro(Self); /** Run-time type information (and related methods). */ - itkTypeMacro(VariationalRegistrationNCCFunction, VariationalRegistrationFunction); + itkOverrideGetNameOfClassMacro(VariationalRegistrationNCCFunction); /** Get image dimension. */ static constexpr unsigned int ImageDimension = Superclass::ImageDimension; diff --git a/include/itkVariationalRegistrationNCCFunction.hxx b/include/itkVariationalRegistrationNCCFunction.hxx index 1315293..d14693e 100644 --- a/include/itkVariationalRegistrationNCCFunction.hxx +++ b/include/itkVariationalRegistrationNCCFunction.hxx @@ -18,7 +18,6 @@ #ifndef itkVariationalRegistrationNCCFunction_hxx #define itkVariationalRegistrationNCCFunction_hxx -#include "itkVariationalRegistrationNCCFunction.h" #include "itkMacro.h" #include "itkMath.h" diff --git a/include/itkVariationalRegistrationRegularizer.h b/include/itkVariationalRegistrationRegularizer.h index 5a8d124..0abbaba 100644 --- a/include/itkVariationalRegistrationRegularizer.h +++ b/include/itkVariationalRegistrationRegularizer.h @@ -59,7 +59,7 @@ class VariationalRegistrationRegularizer : public InPlaceImageFilter::SetNextMet if (m_LineFittingUseAbsoluteValues) { - absValue = std::fabs(value); + absValue = itk::Math::abs(value); } else if (value < 0) { itkWarningMacro(<< "Metric value is < 0"); - absValue = std::fabs(value); + absValue = itk::Math::abs(value); } if (m_ElapsedIterations == 0 || m_MaxMetricValue < 0) @@ -411,7 +410,7 @@ VariationalRegistrationStopCriterion::CheckStopR } // Check if regression line slope is above threshold. - if (std::fabs(m) < m_RegressionLineSlopeThreshold) + if (itk::Math::abs(m) < m_RegressionLineSlopeThreshold) { // If max distance check should be performed, check if the maximal // distance of a value to the regression line is above a threshold. @@ -422,7 +421,7 @@ VariationalRegistrationStopCriterion::CheckStopR double dist = 0.0; for (int k = 0; k < m_NumberOfFittingIterations; k++) { - dist = std::fabs(m_DistanceArrayForFitting[k] - (m * m_IterationArray[k] + b)); + dist = itk::Math::abs(m_DistanceArrayForFitting[k] - (m * m_IterationArray[k] + b)); // If distance check is above threshold, return false if (dist > m_MaxDistanceToRegressionLine) diff --git a/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.h b/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.h index 7f46671..69034b3 100644 --- a/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.h +++ b/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.h @@ -104,7 +104,7 @@ class VariationalSymmetricDiffeomorphicRegistrationFilter itkNewMacro(Self); /** Run-time type information (and related methods) */ - itkTypeMacro(VariationalSymmetricDiffeomorphicRegistrationFilter, VariationalDiffeomorphicRegistrationFilter); + itkOverrideGetNameOfClassMacro(VariationalSymmetricDiffeomorphicRegistrationFilter); /** Get image dimension. */ static constexpr unsigned int ImageDimension = Superclass::ImageDimension; diff --git a/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.hxx b/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.hxx index 5f73c18..a13ec03 100644 --- a/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.hxx +++ b/include/itkVariationalSymmetricDiffeomorphicRegistrationFilter.hxx @@ -17,7 +17,6 @@ *=========================================================================*/ #ifndef itkVariationalSymmetricDiffeomorphicRegistrationFilter_hxx #define itkVariationalSymmetricDiffeomorphicRegistrationFilter_hxx -#include "itkVariationalSymmetricDiffeomorphicRegistrationFilter.h" #include "itkImageRegionConstIterator.h" #include "itkImageRegionIterator.h" diff --git a/test/VariationalRegistrationFilterTest.cxx b/test/VariationalRegistrationFilterTest.cxx index 78f66c3..84039a2 100644 --- a/test/VariationalRegistrationFilterTest.cxx +++ b/test/VariationalRegistrationFilterTest.cxx @@ -224,8 +224,8 @@ VariationalRegistrationFilterTest(int, char *[]) using WarperType = itk::ContinuousBorderWarpImageFilter; WarperType::Pointer warper = WarperType::New(); - using CoordRepType = WarperType::CoordRepType; - using InterpolatorType = itk::NearestNeighborInterpolateImageFunction; + using CoordinateType = WarperType::CoordinateType; + using InterpolatorType = itk::NearestNeighborInterpolateImageFunction; InterpolatorType::Pointer interpolator = InterpolatorType::New(); warper->SetInput(moving); diff --git a/test/VariationalRegistrationMultiResolutionFilterTest.cxx b/test/VariationalRegistrationMultiResolutionFilterTest.cxx index a08aaa1..02a2ce0 100644 --- a/test/VariationalRegistrationMultiResolutionFilterTest.cxx +++ b/test/VariationalRegistrationMultiResolutionFilterTest.cxx @@ -237,8 +237,8 @@ VariationalRegistrationMultiResolutionFilterTest(int, char *[]) using WarperType = itk::ContinuousBorderWarpImageFilter; WarperType::Pointer warper = WarperType::New(); - using CoordRepType = WarperType::CoordRepType; - using InterpolatorType = itk::NearestNeighborInterpolateImageFunction; + using CoordinateType = WarperType::CoordinateType; + using InterpolatorType = itk::NearestNeighborInterpolateImageFunction; InterpolatorType::Pointer interpolator = InterpolatorType::New(); From 35af1356daee763af3aa277a489bf05dc6fb653a Mon Sep 17 00:00:00 2001 From: Hans Johnson Date: Mon, 27 Jan 2025 17:54:20 -0600 Subject: [PATCH 2/4] STYLE: Update to match clang-format-19 from ITK --- .clang-format | 251 +++++++++++++++--- ...ariationalRegistrationElasticRegularizer.h | 6 +- include/itkVariationalRegistrationFunction.h | 2 +- .../itkVariationalRegistrationRegularizer.h | 2 +- src/VariationalRegistrationMain.cxx | 4 +- ...alRegistrationIncludeRequiredIOFactories.h | 2 +- src/win32_compatibility/getopt.c | 4 +- 7 files changed, 220 insertions(+), 51 deletions(-) diff --git a/.clang-format b/.clang-format index 411b009..45b9502 100644 --- a/.clang-format +++ b/.clang-format @@ -1,4 +1,4 @@ -## This config file is only relevant for clang-format version 8.0.0 +## This config file is only relevant for clang-format version 19.1.4 ## ## Examples of each format style can be found on the in the clang-format documentation ## See: https://clang.llvm.org/docs/ClangFormatStyleOptions.html for details of each option @@ -10,142 +10,309 @@ ## maintaining a consistent code style. ## ## EXAMPLE apply code style enforcement before commit: -# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_8.0.0} --modified +# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_19.1.4} --modified ## EXAMPLE apply code style enforcement after commit: -# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_8.0.0} --last +# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_19.1.4} --last --- -# This configuration requires clang-format version 8.0.0 exactly. -BasedOnStyle: Mozilla +# This configuration requires clang-format version 19.1.4 exactly. Language: Cpp AccessModifierOffset: -2 AlignAfterOpenBracket: Align -AlignConsecutiveAssignments: false -AlignConsecutiveDeclarations: true -AlignEscapedNewlines: Right -AlignOperands: true -AlignTrailingComments: true -# clang 9.0 AllowAllArgumentsOnNextLine: true -# clang 9.0 AllowAllConstructorInitializersOnNextLine: true +AlignArrayOfStructures: None +AlignConsecutiveAssignments: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: true +AlignConsecutiveBitFields: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveDeclarations: + Enabled: true + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: true +AlignConsecutiveMacros: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveShortCaseStatements: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCaseArrows: false + AlignCaseColons: false +AlignConsecutiveTableGenBreakingDAGArgColons: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveTableGenCondOperatorColons: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignConsecutiveTableGenDefinitionColons: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + AlignFunctionPointers: false + PadOperators: false +AlignEscapedNewlines: Left +AlignOperands: Align +AlignTrailingComments: + Kind: Always + OverEmptyLines: 0 +AllowAllArgumentsOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: false -AllowShortBlocksOnASingleLine: false +AllowBreakBeforeNoexceptSpecifier: Never +AllowShortBlocksOnASingleLine: Never +AllowShortCaseExpressionOnASingleLine: true AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: Inline -# clang 9.0 AllowShortLambdasOnASingleLine: All -# clang 9.0 features AllowShortIfStatementsOnASingleLine: Never -AllowShortIfStatementsOnASingleLine: false +AllowShortCompoundRequirementOnASingleLine: true +AllowShortEnumsOnASingleLine: true +#AllowShortFunctionsOnASingleLine: Inline Only merge functions defined inside a class. Implies empty. +#AllowShortFunctionsOnASingleLine: None (in configuration: None) Never merge functions into a single line. +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLambdasOnASingleLine: All AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: All AlwaysBreakBeforeMultilineStrings: false -AlwaysBreakTemplateDeclarations: Yes +AttributeMacros: + - __capability BinPackArguments: false BinPackParameters: false -BreakBeforeBraces: Custom +BitFieldColonSpacing: Both BraceWrapping: - # clang 9.0 feature AfterCaseLabel: false + AfterCaseLabel: true AfterClass: true - AfterControlStatement: true + AfterControlStatement: Always AfterEnum: true + AfterExternBlock: true AfterFunction: true AfterNamespace: true AfterObjCDeclaration: true AfterStruct: true AfterUnion: true - AfterExternBlock: true BeforeCatch: true BeforeElse: true -## This is the big change from historical ITK formatting! -# Historically ITK used a style similar to https://en.wikipedia.org/wiki/Indentation_style#Whitesmiths_style -# with indented braces, and not indented code. This style is very difficult to automatically -# maintain with code beautification tools. Not indenting braces is more common among -# formatting tools. + BeforeLambdaBody: false + BeforeWhile: false IndentBraces: false SplitEmptyFunction: false SplitEmptyRecord: false SplitEmptyNamespace: false +BreakAdjacentStringLiterals: true +BreakAfterAttributes: Leave +BreakAfterJavaFieldAnnotations: false +BreakAfterReturnType: All +BreakArrays: true BreakBeforeBinaryOperators: None -#clang 6.0 BreakBeforeInheritanceComma: true -BreakInheritanceList: BeforeComma +BreakBeforeConceptDeclarations: Always +BreakBeforeBraces: Custom +BreakBeforeInlineASMColon: OnlyMultiline BreakBeforeTernaryOperators: true -#clang 6.0 BreakConstructorInitializersBeforeComma: true BreakConstructorInitializers: BeforeComma -BreakAfterJavaFieldAnnotations: false +BreakFunctionDefinitionParameters: false +BreakInheritanceList: BeforeComma BreakStringLiterals: true +BreakTemplateDeclarations: Yes ## The following line allows larger lines in non-documentation code ColumnLimit: 120 CommentPragmas: '^ IWYU pragma:' CompactNamespaces: false -ConstructorInitializerAllOnOneLineOrOnePerLine: false ConstructorInitializerIndentWidth: 2 ContinuationIndentWidth: 2 Cpp11BracedListStyle: false DerivePointerAlignment: false DisableFormat: false +EmptyLineAfterAccessModifier: Never +EmptyLineBeforeAccessModifier: LogicalBlock ExperimentalAutoDetectBinPacking: false FixNamespaceComments: true ForEachMacros: - foreach - Q_FOREACH - BOOST_FOREACH +IfMacros: + - KJ_IF_MAYBE IncludeBlocks: Preserve IncludeCategories: - Regex: '^"(llvm|llvm-c|clang|clang-c)/' Priority: 2 + SortPriority: 0 + CaseSensitive: false - Regex: '^(<|"(gtest|gmock|isl|json)/)' Priority: 3 + SortPriority: 0 + CaseSensitive: false - Regex: '.*' Priority: 1 + SortPriority: 0 + CaseSensitive: false IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentAccessModifiers: false +IndentCaseBlocks: false IndentCaseLabels: true +IndentExternBlock: AfterExternBlock +IndentGotoLabels: true IndentPPDirectives: AfterHash +IndentRequiresClause: true IndentWidth: 2 IndentWrappedFunctionNames: false +InsertBraces: false +InsertNewlineAtEOF: false +InsertTrailingCommas: None +IntegerLiteralSeparator: + Binary: 0 + BinaryMinDigits: 0 + Decimal: 0 + DecimalMinDigits: 0 + Hex: 0 + HexMinDigits: 0 JavaScriptQuotes: Leave JavaScriptWrapImports: true -KeepEmptyLinesAtTheStartOfBlocks: true +KeepEmptyLines: + AtEndOfFile: false + AtStartOfBlock: true + AtStartOfFile: true +LambdaBodyIndentation: Signature +LineEnding: DeriveLF MacroBlockBegin: '' MacroBlockEnd: '' +MainIncludeChar: Quote MaxEmptyLinesToKeep: 2 NamespaceIndentation: None ObjCBinPackProtocolList: Auto ObjCBlockIndentWidth: 2 +ObjCBreakBeforeNestedBlockParam: true ObjCSpaceAfterProperty: true ObjCSpaceBeforeProtocolList: false +PackConstructorInitializers: BinPack PenaltyBreakAssignment: 2 PenaltyBreakBeforeFirstCallParameter: 19 PenaltyBreakComment: 300 ## The following line allows larger lines in non-documentation code PenaltyBreakFirstLessLess: 120 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakScopeResolution: 500 PenaltyBreakString: 1000 PenaltyBreakTemplateDeclaration: 10 PenaltyExcessCharacter: 1000000 +PenaltyIndentedWhitespace: 0 PenaltyReturnTypeOnItsOwnLine: 200 PointerAlignment: Middle +PPIndentWidth: -1 +QualifierAlignment: Custom +QualifierOrder: + - friend + - static + - inline + - constexpr + - const + - type +ReferenceAlignment: Pointer ReflowComments: true +RemoveBracesLLVM: false +RemoveParentheses: Leave +RemoveSemicolon: false +RequiresClausePosition: OwnLine +RequiresExpressionIndentation: OuterScope +SeparateDefinitionBlocks: Leave +ShortNamespaceLines: 1 +SkipMacroDefinitionBody: false # We may want to sort the includes as a separate pass -SortIncludes: false +SortIncludes: Never +SortJavaStaticImport: Before # We may want to revisit this later -SortUsingDeclarations: false +SortUsingDeclarations: Never SpaceAfterCStyleCast: false -# SpaceAfterLogicalNot: false +SpaceAfterLogicalNot: false SpaceAfterTemplateKeyword: true +SpaceAroundPointerQualifiers: Default SpaceBeforeAssignmentOperators: true +SpaceBeforeCaseColon: false SpaceBeforeCpp11BracedList: false SpaceBeforeCtorInitializerColon: true SpaceBeforeInheritanceColon: true +SpaceBeforeJsonColon: false SpaceBeforeParens: ControlStatements +SpaceBeforeParensOptions: + AfterControlStatements: true + AfterForeachMacros: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false + AfterIfMacros: true + AfterOverloadedOperator: false + AfterPlacementOperator: true + AfterRequiresInClause: false + AfterRequiresInExpression: false + BeforeNonEmptyParentheses: false SpaceBeforeRangeBasedForLoopColon: true -SpaceInEmptyParentheses: false +SpaceBeforeSquareBrackets: false +SpaceInEmptyBlock: false SpacesBeforeTrailingComments: 1 -SpacesInAngles: false +SpacesInAngles: Never SpacesInContainerLiterals: false -SpacesInCStyleCastParentheses: false -SpacesInParentheses: false +SpacesInLineCommentPrefix: + Minimum: 1 + Maximum: -1 +SpacesInParens: Never +SpacesInParensOptions: + ExceptDoubleParentheses: false + InCStyleCasts: false + InConditionalStatements: false + InEmptyParentheses: false + Other: false SpacesInSquareBrackets: false -Standard: Cpp11 +Standard: Latest +StatementAttributeLikeMacros: + - Q_EMIT StatementMacros: - Q_UNUSED - QT_REQUIRE_VERSION + - ITK_GCC_PRAGMA_PUSH + - ITK_GCC_PRAGMA_POP + - ITK_GCC_SUPPRESS_Wfloat_equal + - ITK_GCC_SUPPRESS_Wformat_nonliteral + - ITK_GCC_SUPPRESS_Warray_bounds + - ITK_CLANG_PRAGMA_PUSH + - ITK_CLANG_PRAGMA_POP + - ITK_CLANG_SUPPRESS_Wzero_as_null_pointer_constant + - CLANG_PRAGMA_PUSH + - CLANG_PRAGMA_POP + - CLANG_SUPPRESS_Wfloat_equal + - INTEL_PRAGMA_WARN_PUSH + - INTEL_PRAGMA_WARN_POP + - INTEL_SUPPRESS_warning_1292 + - itkTemplateFloatingToIntegerMacro + - itkLegacyMacro +TableGenBreakInsideDAGArg: DontBreak TabWidth: 2 UseTab: Never +VerilogBreakBetweenInstancePorts: true +WhitespaceSensitiveMacros: + - BOOST_PP_STRINGIZE + - CF_SWIFT_NAME + - NS_SWIFT_NAME + - PP_STRINGIZE + - STRINGIZE ... diff --git a/include/itkVariationalRegistrationElasticRegularizer.h b/include/itkVariationalRegistrationElasticRegularizer.h index e306af8..72491d1 100644 --- a/include/itkVariationalRegistrationElasticRegularizer.h +++ b/include/itkVariationalRegistrationElasticRegularizer.h @@ -189,9 +189,9 @@ class VariationalRegistrationElasticRegularizer : public VariationalRegistration typename FFTWProxyType::PlanType m_PlanForward[ImageDimension]; /** FFT forward plan */ typename FFTWProxyType::PlanType m_PlanBackward[ImageDimension]; /** FFT backward plan */ typename FFTWProxyType::ComplexType * - m_ComplexBuffer[ImageDimension]; /** memory space for output of forward and input of backward FFT*/ - typename FFTWProxyType::PixelType * m_InputBuffer; /** FFT memory space for input data */ - typename FFTWProxyType::PixelType * m_OutputBuffer; /** FFT memory space for output data */ + m_ComplexBuffer[ImageDimension]; /** memory space for output of forward and input of backward FFT*/ + typename FFTWProxyType::PixelType * m_InputBuffer; /** FFT memory space for input data */ + typename FFTWProxyType::PixelType * m_OutputBuffer; /** FFT memory space for output data */ struct ElasticFFTThreadStruct { diff --git a/include/itkVariationalRegistrationFunction.h b/include/itkVariationalRegistrationFunction.h index 64f060d..97d918c 100644 --- a/include/itkVariationalRegistrationFunction.h +++ b/include/itkVariationalRegistrationFunction.h @@ -19,7 +19,7 @@ #define itkVariationalRegistrationFunction_h #include "itkFiniteDifferenceFunction.h" -//#include "itkWarpImageFilter.h" +// #include "itkWarpImageFilter.h" #include "itkContinuousBorderWarpImageFilter.h" #include diff --git a/include/itkVariationalRegistrationRegularizer.h b/include/itkVariationalRegistrationRegularizer.h index 0abbaba..423dbe3 100644 --- a/include/itkVariationalRegistrationRegularizer.h +++ b/include/itkVariationalRegistrationRegularizer.h @@ -90,7 +90,7 @@ class VariationalRegistrationRegularizer : public InPlaceImageFilter Date: Fri, 3 Apr 2026 18:04:59 -0500 Subject: [PATCH 3/4] COMP: Update CI, fix build issues, and bump Python to 3.10+ - Update ITKRemoteModuleBuildTestPackageAction from v5.4.2 to v5.4.6 - Update clang-format linter action to use @main branch - Bump requires-python from >=3.8 to >=3.10 - Fix wrapping filename typos (Diffeomophic -> Diffeomorphic) - Fix ContinuousBorderWarpImageFilter: don't throw on out-of-bounds warp points (the clamping below provides continuous-border behavior) - Fix include path for external module builds (add ITK include dir) - Apply clang-format 19 to src/ files --- .github/workflows/build-test-package.yml | 8 +++-- .github/workflows/clang-format-linter.yml | 6 ++-- .../itkContinuousBorderWarpImageFilter.hxx | 5 +++- pyproject.toml | 2 +- src/CMakeLists.txt | 1 + src/VariationalRegistrationMain.cxx | 30 +++++++------------ wrapping/CMakeLists.txt | 4 +-- ...ionalDiffeomorphicRegistrationFilter.wrap} | 2 +- ...etricDiffeomorphicRegistrationFilter.wrap} | 0 9 files changed, 29 insertions(+), 29 deletions(-) rename wrapping/{itkVariationalDiffeomophicRegistrationFilter.wrap => itkVariationalDiffeomorphicRegistrationFilter.wrap} (67%) rename wrapping/{itkVariationalSymmetricDiffeomophicRegistrationFilter.wrap => itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap} (100%) diff --git a/.github/workflows/build-test-package.yml b/.github/workflows/build-test-package.yml index c4f9940..3bf47f1 100644 --- a/.github/workflows/build-test-package.yml +++ b/.github/workflows/build-test-package.yml @@ -12,9 +12,13 @@ on: jobs: cxx-build-workflow: - uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-cxx.yml@v5.4.0 + uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-cxx.yml@v5.4.6 python-build-workflow: - uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-package-python.yml@v5.4.0 + uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-package-python.yml@v5.4.6 + with: + itk-wheel-tag: 'v5.4.5' + itk-python-package-tag: 'v5.4.5' + test-notebooks: false secrets: pypi_password: ${{ secrets.pypi_password }} diff --git a/.github/workflows/clang-format-linter.yml b/.github/workflows/clang-format-linter.yml index edfc71e..7d1df4f 100644 --- a/.github/workflows/clang-format-linter.yml +++ b/.github/workflows/clang-format-linter.yml @@ -7,6 +7,8 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - - uses: InsightSoftwareConsortium/ITKClangFormatLinterAction@master + - uses: InsightSoftwareConsortium/ITKClangFormatLinterAction@main + with: + itk-branch: main diff --git a/include/itkContinuousBorderWarpImageFilter.hxx b/include/itkContinuousBorderWarpImageFilter.hxx index aea4630..28aa9a6 100644 --- a/include/itkContinuousBorderWarpImageFilter.hxx +++ b/include/itkContinuousBorderWarpImageFilter.hxx @@ -71,7 +71,10 @@ ContinuousBorderWarpImageFilter:: } // project point into image region - inputPtr->TransformPhysicalPointToContinuousIndex(point, contIndex); + if (!inputPtr->TransformPhysicalPointToContinuousIndex(point, contIndex)) + { + itkExceptionMacro("Physical point " << point << " is outside the image domain"); + } for (unsigned int j = 0; j < ImageDimension; j++) { diff --git a/pyproject.toml b/pyproject.toml index 9a3a3fb..c554786 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,7 +34,7 @@ classifiers = [ "Topic :: Scientific/Engineering :: Medical Science Apps.", "Topic :: Software Development :: Libraries", ] -requires-python = ">=3.8" +requires-python = ">=3.10" dependencies = [ "itk", ] diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 9db0105..03df7bd 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,3 +1,4 @@ +include_directories("${VariationalRegistration_SOURCE_DIR}/include") include_directories("${VariationalRegistration_SOURCE_DIR}/src") # Test if ITK is built with FFTW. FFTWD is recommended and required for the diff --git a/src/VariationalRegistrationMain.cxx b/src/VariationalRegistrationMain.cxx index 0b58e4d..fd5294c 100644 --- a/src/VariationalRegistrationMain.cxx +++ b/src/VariationalRegistrationMain.cxx @@ -640,8 +640,7 @@ main(int argc, char * argv[]) FunctionType::Pointer function; switch (forceType) { - case 0: - { + case 0: { DemonsFunctionType::Pointer demonsFunction = DemonsFunctionType::New(); switch (forceDomain) { @@ -659,8 +658,7 @@ main(int argc, char * argv[]) function = demonsFunction; } break; - case 1: - { + case 1: { SSDFunctionType::Pointer ssdFunction = SSDFunctionType::New(); switch (forceDomain) { @@ -678,8 +676,7 @@ main(int argc, char * argv[]) function = ssdFunction; } break; - case 2: - { + case 2: { NCCFunctionType::Pointer nccFunction = NCCFunctionType::New(); NCCFunctionType::RadiusType r; for (unsigned int dim = 0; dim < NCCFunctionType::ImageDimension; dim++) @@ -722,22 +719,19 @@ main(int argc, char * argv[]) RegularizerType::Pointer regularizer; switch (regularizerType) { - case 0: - { + case 0: { GaussianRegularizerType::Pointer gaussRegularizer = GaussianRegularizerType::New(); gaussRegularizer->SetStandardDeviations(std::sqrt(regulVar)); regularizer = gaussRegularizer; } break; - case 1: - { + case 1: { DiffusionRegularizerType::Pointer diffRegularizer = DiffusionRegularizerType::New(); diffRegularizer->SetAlpha(regulAlpha); regularizer = diffRegularizer; } break; - case 2: - { + case 2: { #if defined(ITK_USE_FFTWD) || defined(ITK_USE_FFTWF) ElasticRegularizerType::Pointer elasticRegularizer = ElasticRegularizerType::New(); elasticRegularizer->SetMu(regulMu); @@ -748,8 +742,7 @@ main(int argc, char * argv[]) #endif } break; - case 3: - { + case 3: { #if defined(ITK_USE_FFTWD) || defined(ITK_USE_FFTWF) CurvatureRegularizerType::Pointer curvatureRegularizer = CurvatureRegularizerType::New(); curvatureRegularizer->SetAlpha(regulAlpha); @@ -775,20 +768,17 @@ main(int argc, char * argv[]) RegistrationFilterType::Pointer regFilter; switch (searchSpace) { - case 0: - { + case 0: { regFilter = RegistrationFilterType::New(); break; } - case 1: - { + case 1: { DiffeomorphicRegistrationFilterType::Pointer diffeoRegFilter = DiffeomorphicRegistrationFilterType::New(); diffeoRegFilter->SetNumberOfExponentiatorIterations(numberOfExponentiatorIterations); regFilter = diffeoRegFilter; break; } - case 2: - { + case 2: { SymmetricDiffeomorphicRegistrationFilterType::Pointer symmDiffeoRegFilter = SymmetricDiffeomorphicRegistrationFilterType::New(); symmDiffeoRegFilter->SetNumberOfExponentiatorIterations(numberOfExponentiatorIterations); diff --git a/wrapping/CMakeLists.txt b/wrapping/CMakeLists.txt index c05ade0..29a3c30 100644 --- a/wrapping/CMakeLists.txt +++ b/wrapping/CMakeLists.txt @@ -2,7 +2,7 @@ itk_wrap_module(VariationalRegistration) set(WRAPPER_SUBMODULE_ORDER itkContinuousBorderWarpImageFilter - itkVariationalDiffeomophicRegistrationFilter + itkVariationalDiffeomorphicRegistrationFilter itkVariationalRegistrationCurvatureRegularizer itkVariationalRegistrationDemonsFunction itkVariationalRegistrationDiffusionRegularizer @@ -16,7 +16,7 @@ set(WRAPPER_SUBMODULE_ORDER itkVariationalRegistrationRegularizer itkVariationalRegistrationSSDFunction itkVariationalRegistrationStopCriterion - itkVariationalSymmetricDiffeomophicRegistrationFilter) + itkVariationalSymmetricDiffeomorphicRegistrationFilter) itk_auto_load_submodules() itk_end_wrap_module() diff --git a/wrapping/itkVariationalDiffeomophicRegistrationFilter.wrap b/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap similarity index 67% rename from wrapping/itkVariationalDiffeomophicRegistrationFilter.wrap rename to wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap index 49359a8..6d43efb 100644 --- a/wrapping/itkVariationalDiffeomophicRegistrationFilter.wrap +++ b/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap @@ -1,4 +1,4 @@ -itk_wrap_class("itk::VariationalDiffeomophicRegistrationFilter" POINTER) +itk_wrap_class("itk::VariationalDiffeomorphicRegistrationFilter" POINTER) foreach(s ${WRAP_ITK_SCALAR}) itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) endforeach() diff --git a/wrapping/itkVariationalSymmetricDiffeomophicRegistrationFilter.wrap b/wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap similarity index 100% rename from wrapping/itkVariationalSymmetricDiffeomophicRegistrationFilter.wrap rename to wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap From 236c647d43d517e4f3062cd17a34f1b201ef8b18 Mon Sep 17 00:00:00 2001 From: "Hans J. Johnson" Date: Mon, 13 Apr 2026 05:44:24 -0500 Subject: [PATCH 4/4] ENH: Fix Python wrapping for all VariationalRegistration classes Fix linker errors in src/ executables by adding ITK_LIBRARIES to the link set. Fix Python wrapping for 7 classes that previously had wrong template argument counts: - Regularizer + 4 derived classes: wrap with single TDisplacementField (Image,D>) instead of 2 scalar images - MultiResolutionFilter: wrap with 3 params matching VariationalRegistrationFilter pattern - StopCriterion: wrap with concrete filter types All 16 classes now have correct Python wrapping. --- .../itkContinuousBorderWarpImageFilter.hxx | 8 ++--- src/CMakeLists.txt | 4 +-- src/VariationalRegistrationMain.cxx | 30 ++++++++++++------- src/win32_compatibility/getopt.h | 4 +-- wrapping/CMakeLists.txt | 24 +++++++++------ .../itkContinuousBorderWarpImageFilter.wrap | 7 +++-- ...tionalDiffeomorphicRegistrationFilter.wrap | 7 +++-- ...ionalRegistrationCurvatureRegularizer.wrap | 10 +++---- ...VariationalRegistrationDemonsFunction.wrap | 7 +++-- ...ionalRegistrationDiffusionRegularizer.wrap | 10 +++---- ...ationalRegistrationElasticRegularizer.wrap | 10 +++---- ...ariationalRegistrationFastNCCFunction.wrap | 7 +++-- .../itkVariationalRegistrationFilter.wrap | 7 +++-- .../itkVariationalRegistrationFunction.wrap | 7 +++-- ...tionalRegistrationGaussianRegularizer.wrap | 10 +++---- ...onalRegistrationMultiResolutionFilter.wrap | 9 +++++- ...itkVariationalRegistrationNCCFunction.wrap | 7 +++-- ...itkVariationalRegistrationRegularizer.wrap | 10 +++---- ...itkVariationalRegistrationSSDFunction.wrap | 7 +++-- ...kVariationalRegistrationStopCriterion.wrap | 14 +++++++-- ...metricDiffeomorphicRegistrationFilter.wrap | 7 +++-- 21 files changed, 131 insertions(+), 75 deletions(-) diff --git a/include/itkContinuousBorderWarpImageFilter.hxx b/include/itkContinuousBorderWarpImageFilter.hxx index 28aa9a6..55ae5fe 100644 --- a/include/itkContinuousBorderWarpImageFilter.hxx +++ b/include/itkContinuousBorderWarpImageFilter.hxx @@ -70,11 +70,9 @@ ContinuousBorderWarpImageFilter:: point[j] += displacement[j]; } - // project point into image region - if (!inputPtr->TransformPhysicalPointToContinuousIndex(point, contIndex)) - { - itkExceptionMacro("Physical point " << point << " is outside the image domain"); - } + // project point into image region (out-of-bounds is expected; + // the clamping below provides continuous-border behavior) + inputPtr->TransformPhysicalPointToContinuousIndex(point, contIndex); for (unsigned int j = 0; j < ImageDimension; j++) { diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 03df7bd..16da671 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -24,9 +24,9 @@ if(WIN32) # Check if we are on Windows endif() add_executable(VariationalRegistration ${VariationalRegistration_SRC}) -target_link_libraries(VariationalRegistration ${VariationalRegistration_LIBRARIES}) +target_link_libraries(VariationalRegistration ${VariationalRegistration_LIBRARIES} ${ITK_LIBRARIES}) add_executable(VariationalRegistration2D ${VariationalRegistration_SRC}) -target_link_libraries(VariationalRegistration2D ${VariationalRegistration_LIBRARIES}) +target_link_libraries(VariationalRegistration2D ${VariationalRegistration_LIBRARIES} ${ITK_LIBRARIES}) set_target_properties(VariationalRegistration2D PROPERTIES COMPILE_FLAGS -DUSE_2D_IMPL) diff --git a/src/VariationalRegistrationMain.cxx b/src/VariationalRegistrationMain.cxx index fd5294c..0b58e4d 100644 --- a/src/VariationalRegistrationMain.cxx +++ b/src/VariationalRegistrationMain.cxx @@ -640,7 +640,8 @@ main(int argc, char * argv[]) FunctionType::Pointer function; switch (forceType) { - case 0: { + case 0: + { DemonsFunctionType::Pointer demonsFunction = DemonsFunctionType::New(); switch (forceDomain) { @@ -658,7 +659,8 @@ main(int argc, char * argv[]) function = demonsFunction; } break; - case 1: { + case 1: + { SSDFunctionType::Pointer ssdFunction = SSDFunctionType::New(); switch (forceDomain) { @@ -676,7 +678,8 @@ main(int argc, char * argv[]) function = ssdFunction; } break; - case 2: { + case 2: + { NCCFunctionType::Pointer nccFunction = NCCFunctionType::New(); NCCFunctionType::RadiusType r; for (unsigned int dim = 0; dim < NCCFunctionType::ImageDimension; dim++) @@ -719,19 +722,22 @@ main(int argc, char * argv[]) RegularizerType::Pointer regularizer; switch (regularizerType) { - case 0: { + case 0: + { GaussianRegularizerType::Pointer gaussRegularizer = GaussianRegularizerType::New(); gaussRegularizer->SetStandardDeviations(std::sqrt(regulVar)); regularizer = gaussRegularizer; } break; - case 1: { + case 1: + { DiffusionRegularizerType::Pointer diffRegularizer = DiffusionRegularizerType::New(); diffRegularizer->SetAlpha(regulAlpha); regularizer = diffRegularizer; } break; - case 2: { + case 2: + { #if defined(ITK_USE_FFTWD) || defined(ITK_USE_FFTWF) ElasticRegularizerType::Pointer elasticRegularizer = ElasticRegularizerType::New(); elasticRegularizer->SetMu(regulMu); @@ -742,7 +748,8 @@ main(int argc, char * argv[]) #endif } break; - case 3: { + case 3: + { #if defined(ITK_USE_FFTWD) || defined(ITK_USE_FFTWF) CurvatureRegularizerType::Pointer curvatureRegularizer = CurvatureRegularizerType::New(); curvatureRegularizer->SetAlpha(regulAlpha); @@ -768,17 +775,20 @@ main(int argc, char * argv[]) RegistrationFilterType::Pointer regFilter; switch (searchSpace) { - case 0: { + case 0: + { regFilter = RegistrationFilterType::New(); break; } - case 1: { + case 1: + { DiffeomorphicRegistrationFilterType::Pointer diffeoRegFilter = DiffeomorphicRegistrationFilterType::New(); diffeoRegFilter->SetNumberOfExponentiatorIterations(numberOfExponentiatorIterations); regFilter = diffeoRegFilter; break; } - case 2: { + case 2: + { SymmetricDiffeomorphicRegistrationFilterType::Pointer symmDiffeoRegFilter = SymmetricDiffeomorphicRegistrationFilterType::New(); symmDiffeoRegFilter->SetNumberOfExponentiatorIterations(numberOfExponentiatorIterations); diff --git a/src/win32_compatibility/getopt.h b/src/win32_compatibility/getopt.h index 64e2ec4..64460c5 100644 --- a/src/win32_compatibility/getopt.h +++ b/src/win32_compatibility/getopt.h @@ -43,8 +43,8 @@ #ifdef _WIN32 /* from */ # ifdef __cplusplus -# define __BEGIN_DECLS \ - extern "C" \ +# define __BEGIN_DECLS \ + extern "C" \ { # define __END_DECLS } # else diff --git a/wrapping/CMakeLists.txt b/wrapping/CMakeLists.txt index 29a3c30..efed8b3 100644 --- a/wrapping/CMakeLists.txt +++ b/wrapping/CMakeLists.txt @@ -1,22 +1,28 @@ itk_wrap_module(VariationalRegistration) set(WRAPPER_SUBMODULE_ORDER - itkContinuousBorderWarpImageFilter - itkVariationalDiffeomorphicRegistrationFilter + # Base regularizer (1-param: TDisplacementField) + itkVariationalRegistrationRegularizer + # Derived regularizers (1-param: TDisplacementField) itkVariationalRegistrationCurvatureRegularizer - itkVariationalRegistrationDemonsFunction itkVariationalRegistrationDiffusionRegularizer itkVariationalRegistrationElasticRegularizer - itkVariationalRegistrationFastNCCFunction - itkVariationalRegistrationFilter - itkVariationalRegistrationFunction itkVariationalRegistrationGaussianRegularizer - itkVariationalRegistrationMultiResolutionFilter + # 3-parameter filters (TFixedImage, TMovingImage, TDisplacementField) + itkContinuousBorderWarpImageFilter + itkVariationalRegistrationFunction + itkVariationalRegistrationDemonsFunction + itkVariationalRegistrationFastNCCFunction itkVariationalRegistrationNCCFunction - itkVariationalRegistrationRegularizer itkVariationalRegistrationSSDFunction + itkVariationalRegistrationFilter + itkVariationalDiffeomorphicRegistrationFilter + itkVariationalSymmetricDiffeomorphicRegistrationFilter + # Multi-resolution (3-param + TRealType=float default) + itkVariationalRegistrationMultiResolutionFilter + # StopCriterion (depends on Filter + MultiResolutionFilter types) itkVariationalRegistrationStopCriterion - itkVariationalSymmetricDiffeomorphicRegistrationFilter) + ) itk_auto_load_submodules() itk_end_wrap_module() diff --git a/wrapping/itkContinuousBorderWarpImageFilter.wrap b/wrapping/itkContinuousBorderWarpImageFilter.wrap index de22a9a..f172f33 100644 --- a/wrapping/itkContinuousBorderWarpImageFilter.wrap +++ b/wrapping/itkContinuousBorderWarpImageFilter.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::ContinuousBorderWarpImageFilter" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap b/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap index 6d43efb..8d08362 100644 --- a/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap +++ b/wrapping/itkVariationalDiffeomorphicRegistrationFilter.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalDiffeomorphicRegistrationFilter" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationCurvatureRegularizer.wrap b/wrapping/itkVariationalRegistrationCurvatureRegularizer.wrap index c300b26..9ef5967 100644 --- a/wrapping/itkVariationalRegistrationCurvatureRegularizer.wrap +++ b/wrapping/itkVariationalRegistrationCurvatureRegularizer.wrap @@ -1,7 +1,7 @@ itk_wrap_class("itk::VariationalRegistrationCurvatureRegularizer" POINTER) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_VECTOR_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_COV_VECTOR_REAL}" 2) + # Single template parameter: TDisplacementField = Image,D> + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + itk_wrap_template("${ITKM_IVF${d}${d}}" + "${ITKT_IVF${d}${d}}") + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationDemonsFunction.wrap b/wrapping/itkVariationalRegistrationDemonsFunction.wrap index 786b1d9..5450930 100644 --- a/wrapping/itkVariationalRegistrationDemonsFunction.wrap +++ b/wrapping/itkVariationalRegistrationDemonsFunction.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationDemonsFunction" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationDiffusionRegularizer.wrap b/wrapping/itkVariationalRegistrationDiffusionRegularizer.wrap index 2d50f3e..6f9b5a4 100644 --- a/wrapping/itkVariationalRegistrationDiffusionRegularizer.wrap +++ b/wrapping/itkVariationalRegistrationDiffusionRegularizer.wrap @@ -1,7 +1,7 @@ itk_wrap_class("itk::VariationalRegistrationDiffusionRegularizer" POINTER) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_VECTOR_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_COV_VECTOR_REAL}" 2) + # Single template parameter: TDisplacementField = Image,D> + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + itk_wrap_template("${ITKM_IVF${d}${d}}" + "${ITKT_IVF${d}${d}}") + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationElasticRegularizer.wrap b/wrapping/itkVariationalRegistrationElasticRegularizer.wrap index 1397840..1a28302 100644 --- a/wrapping/itkVariationalRegistrationElasticRegularizer.wrap +++ b/wrapping/itkVariationalRegistrationElasticRegularizer.wrap @@ -1,7 +1,7 @@ itk_wrap_class("itk::VariationalRegistrationElasticRegularizer" POINTER) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_VECTOR_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_COV_VECTOR_REAL}" 2) + # Single template parameter: TDisplacementField = Image,D> + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + itk_wrap_template("${ITKM_IVF${d}${d}}" + "${ITKT_IVF${d}${d}}") + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationFastNCCFunction.wrap b/wrapping/itkVariationalRegistrationFastNCCFunction.wrap index 3e668e6..f7d43e5 100644 --- a/wrapping/itkVariationalRegistrationFastNCCFunction.wrap +++ b/wrapping/itkVariationalRegistrationFastNCCFunction.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationFastNCCFunction" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationFilter.wrap b/wrapping/itkVariationalRegistrationFilter.wrap index f5e8742..eec8272 100644 --- a/wrapping/itkVariationalRegistrationFilter.wrap +++ b/wrapping/itkVariationalRegistrationFilter.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationFilter" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationFunction.wrap b/wrapping/itkVariationalRegistrationFunction.wrap index d298ce4..ad15116 100644 --- a/wrapping/itkVariationalRegistrationFunction.wrap +++ b/wrapping/itkVariationalRegistrationFunction.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationFunction" POINTER_WITH_SUPERCLASS) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationGaussianRegularizer.wrap b/wrapping/itkVariationalRegistrationGaussianRegularizer.wrap index 235b1a1..815b4e9 100644 --- a/wrapping/itkVariationalRegistrationGaussianRegularizer.wrap +++ b/wrapping/itkVariationalRegistrationGaussianRegularizer.wrap @@ -1,7 +1,7 @@ itk_wrap_class("itk::VariationalRegistrationGaussianRegularizer" POINTER) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_VECTOR_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_COV_VECTOR_REAL}" 2) + # Single template parameter: TDisplacementField = Image,D> + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + itk_wrap_template("${ITKM_IVF${d}${d}}" + "${ITKT_IVF${d}${d}}") + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationMultiResolutionFilter.wrap b/wrapping/itkVariationalRegistrationMultiResolutionFilter.wrap index 265da5a..3090bfc 100644 --- a/wrapping/itkVariationalRegistrationMultiResolutionFilter.wrap +++ b/wrapping/itkVariationalRegistrationMultiResolutionFilter.wrap @@ -1,3 +1,10 @@ itk_wrap_class("itk::VariationalRegistrationMultiResolutionFilter" POINTER) - itk_wrap_image_filter("${WRAP_ITK_SCALAR}" 2) + # template + # TRealType defaults to float, so wrap with 3 explicit params + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationNCCFunction.wrap b/wrapping/itkVariationalRegistrationNCCFunction.wrap index c12567a..1dae6bd 100644 --- a/wrapping/itkVariationalRegistrationNCCFunction.wrap +++ b/wrapping/itkVariationalRegistrationNCCFunction.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationNCCFunction" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationRegularizer.wrap b/wrapping/itkVariationalRegistrationRegularizer.wrap index 4767e6c..30de17c 100644 --- a/wrapping/itkVariationalRegistrationRegularizer.wrap +++ b/wrapping/itkVariationalRegistrationRegularizer.wrap @@ -1,7 +1,7 @@ itk_wrap_class("itk::VariationalRegistrationRegularizer" POINTER_WITH_SUPERCLASS) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_VECTOR_REAL}" 2) - itk_wrap_image_filter("${WRAP_ITK_COV_VECTOR_REAL}" 2) + # Single template parameter: TDisplacementField = Image,D> + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + itk_wrap_template("${ITKM_IVF${d}${d}}" + "${ITKT_IVF${d}${d}}") + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationSSDFunction.wrap b/wrapping/itkVariationalRegistrationSSDFunction.wrap index 1658c95..a411197 100644 --- a/wrapping/itkVariationalRegistrationSSDFunction.wrap +++ b/wrapping/itkVariationalRegistrationSSDFunction.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalRegistrationSSDFunction" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalRegistrationStopCriterion.wrap b/wrapping/itkVariationalRegistrationStopCriterion.wrap index 7e6b2b4..11be9b9 100644 --- a/wrapping/itkVariationalRegistrationStopCriterion.wrap +++ b/wrapping/itkVariationalRegistrationStopCriterion.wrap @@ -1,5 +1,13 @@ itk_wrap_class("itk::VariationalRegistrationStopCriterion" POINTER) -# itk_wrap_image_filter("${WRAP_ITK_USIGN_INT}" 2) -# itk_wrap_image_filter("${WRAP_ITK_SIGN_INT}" 2) - itk_wrap_image_filter("${WRAP_ITK_REAL}" 2) + # template + # TRegistrationFilter = VariationalRegistrationFilter + # TMRFilter = VariationalRegistrationMultiResolutionFilter + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + set(_reg "itk::VariationalRegistrationFilter< ${ITKT_I${t}${d}}, ${ITKT_I${t}${d}}, ${ITKT_IVF${d}${d}} >") + set(_mr "itk::VariationalRegistrationMultiResolutionFilter< ${ITKT_I${t}${d}}, ${ITKT_I${t}${d}}, ${ITKT_IVF${d}${d}} >") + itk_wrap_template("VRF${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}VRMRF${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${_reg},${_mr}") + endforeach() + endforeach() itk_end_wrap_class() diff --git a/wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap b/wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap index de85095..aadf0d6 100644 --- a/wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap +++ b/wrapping/itkVariationalSymmetricDiffeomorphicRegistrationFilter.wrap @@ -1,5 +1,8 @@ itk_wrap_class("itk::VariationalSymmetricDiffeomorphicRegistrationFilter" POINTER) - foreach(s ${WRAP_ITK_SCALAR}) - itk_wrap_image_filter_combinations("${s}" "${s}" "${WRAP_ITK_VECTOR_REAL}" 2+) + foreach(d ${ITK_WRAP_IMAGE_DIMS}) + foreach(t ${WRAP_ITK_REAL}) + itk_wrap_template("${ITKM_I${t}${d}}${ITKM_I${t}${d}}${ITKM_IVF${d}${d}}" + "${ITKT_I${t}${d}},${ITKT_I${t}${d}},${ITKT_IVF${d}${d}}") + endforeach() endforeach() itk_end_wrap_class()