ENH: Ingest ITKMontage remote module into Modules/Registration/Montage

Modules/Registration/Montage/CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.16.3)
+
+if(CMAKE_CXX_STANDARD EQUAL "98")
+  message(
+    FATAL_ERROR
+    "CMAKE_CXX_STANDARD:STRING=98 is not supported in ITK version 5 and greater."
+  )
+endif()
+
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17) # Supported values are ``17``, ``20``, and ``23``.
+endif()
+if(NOT CMAKE_CXX_STANDARD_REQUIRED)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+if(NOT CMAKE_CXX_EXTENSIONS)
+  set(CMAKE_CXX_EXTENSIONS OFF)
+endif()
+
+project(Montage)
+
+set(Montage_LIBRARIES Montage)
+
+# Suppress warnings about potentially uninstantiated static members
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  include(CheckCXXCompilerFlag)
+  check_cxx_compiler_flag(
+    "-Wno-undefined-var-template"
+    COMPILER_HAS_NO_UNDEFINED_VAR_TEMPLATE
+  )
+  if(COMPILER_HAS_NO_UNDEFINED_VAR_TEMPLATE)
+    set(CMAKE_CXX_FLAGS "-Wno-undefined-var-template ${CMAKE_CXX_FLAGS}")
+  endif()
+endif()
+
+if(NOT ITK_SOURCE_DIR)
+  find_package(ITK REQUIRED)
+  list(APPEND CMAKE_MODULE_PATH ${ITK_CMAKE_DIR})
+  include(ITKModuleExternal)
+else()
+  set(ITK_DIR ${CMAKE_BINARY_DIR})
+  itk_module_impl()
+endif()
+
+itk_module_examples()

Modules/Registration/Montage/README.md

@@ -0,0 +1,60 @@
+# Montage
+
+Mosaic-stitching and 3D reconstruction of large datasets from a
+collection of partially-overlapping 2D slices, built around phase
+correlation image registration.  Core classes:
+
+- `itk::PhaseCorrelationImageRegistrationMethod`
+- `itk::PhaseCorrelationOperator`
+- `itk::PhaseCorrelationOptimizer`
+- `itk::TileMontage`
+- `itk::TileMergeImageFilter`
+- `itk::TileConfiguration`
+- `itk::NMinimaMaximaImageCalculator`
+
+## Upstream
+
+This module was originally developed and maintained as a standalone
+remote module at
+<https://github.com/InsightSoftwareConsortium/ITKMontage>.  The
+contents of `include/`, `src/`, `test/`, `wrapping/`, and the two
+CMake build descriptors (`CMakeLists.txt`, `itk-module.cmake`) were
+ingested into ITK via `Utilities/Maintenance/RemoteModuleIngest/`
+(see PR #6098 for the tooling).
+
+The standalone upstream repository should be treated as archived
+once this ingest lands.  Refer to its tags and release history for
+provenance, but future development happens in-tree here.
+
+## What is intentionally NOT ingested
+
+The whitelist-based ingest deliberately excludes the following
+upstream content from ITK:
+
+- `examples/` — applied demonstration code and sample datasets;
+  lives with the archived upstream (and selectively relocated to
+  [`Examples/`](https://github.com/InsightSoftwareConsortium/ITK/tree/main/Examples)
+  in a follow-up PR if broadly useful).
+- `.github/workflows/` — upstream-specific CI configuration; ITK's
+  in-tree CI covers the module via the central pipeline.
+- `CTestConfig.cmake` — pointed at a standalone CDash project that
+  no longer applies in-tree.
+- `README.md`, `LICENSE`, `requirements.txt`, `pyproject.toml` and
+  similar scaffolding — top-level packaging files that are either
+  inherited from ITK's own policy (Apache 2.0 license, etc.) or
+  irrelevant in-tree.
+
+If you need any of the above, consult the archived upstream.
+
+## Compliance level
+
+Previously tracked as a level-3 remote module (see the superseded
+`Modules/Remote/Montage.remote.cmake`).  In-tree placement does not
+automatically raise the compliance level; continued stewardship is
+needed to reach levels 4 and 5.
+
+## Contact
+
+Originally authored and maintained by Dženan Zukić
+&lt;dzenan.zukic@kitware.com&gt;.  In-tree maintenance follows ITK's
+standard review process.

Modules/Registration/Montage/include/itkNMinimaMaximaImageCalculator.h

@@ -0,0 +1,158 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef itkNMinimaMaximaImageCalculator_h
+#define itkNMinimaMaximaImageCalculator_h
+
+#include "itkMacro.h"
+#include "itkObject.h"
+#include "itkObjectFactory.h"
+#include <mutex>
+#include <vector>
+
+namespace itk
+{
+/** \class NMinimaMaximaImageCalculator
+ *  \brief Computes the N highest and/or lowest intensity values of an image.
+ *
+ * This class is templated over input image type. If only Maxima or
+ * Minima are needed, just call ComputeMaxima() or ComputeMinima().
+ * Compute() will compute both.
+ *
+ * \ingroup Operators
+ * \ingroup ITKCommon
+ * \ingroup Montage
+ */
+template <typename TInputImage>
+class ITK_TEMPLATE_EXPORT NMinimaMaximaImageCalculator : public Object
+{
+public:
+  ITK_DISALLOW_COPY_AND_MOVE(NMinimaMaximaImageCalculator);
+
+  /** Standard class type aliases. */
+  using Self = NMinimaMaximaImageCalculator;
+  using Superclass = Object;
+  using Pointer = SmartPointer<Self>;
+  using ConstPointer = SmartPointer<const Self>;
+
+  /** Method for creation through the object factory. */
+  itkNewMacro(Self);
+
+  /** Run-time type information (and related methods). */
+  itkOverrideGetNameOfClassMacro(NMinimaMaximaImageCalculator);
+
+  /** Type definition for the input image. */
+  using ImageType = TInputImage;
+
+  /** Pointer type for the image. */
+  using ImagePointer = typename TInputImage::Pointer;
+
+  /** Const Pointer type for the image. */
+  using ImageConstPointer = typename TInputImage::ConstPointer;
+
+  /** Type definition for the input image pixel type. */
+  using PixelType = typename TInputImage::PixelType;
+
+  /** Image dimensionality */
+  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
+  // constexpr unsigned ImageDimension = TInputImage::VImageDimension;
+
+  /** Type definition for the input image index type. */
+  using IndexType = typename TInputImage::IndexType;
+
+  /** Type definition for the input image region type. */
+  using RegionType = typename TInputImage::RegionType;
+
+  /** Sorted vector of minima or maxima. */
+  using ValueVector = std::vector<PixelType>;
+
+  /** Sorted vector of pixel indices of minima or maxima. */
+  using IndexVector = std::vector<IndexType>;
+
+
+  /** Set the input image. */
+  itkSetConstObjectMacro(Image, ImageType);
+
+  /** Compute the minimum value of intensity of the input image. */
+  void
+  ComputeMinima();
+
+  /** Compute the maximum value of intensity of the input image. */
+  void
+  ComputeMaxima();
+
+  /** Compute the minimum and maximum values of intensity of the input image. */
+  void
+  Compute();
+
+  /** Return the N minimum intensity values. */
+  itkGetConstReferenceMacro(Minima, ValueVector);
+
+  /** Return the N maximum intensity values. */
+  itkGetConstReferenceMacro(Maxima, ValueVector);
+
+  /** Return the indices of the N minimum intensity values. */
+  itkGetConstReferenceMacro(IndicesOfMinima, IndexVector);
+
+  /** Return the indices of the N maximum intensity values. */
+  itkGetConstReferenceMacro(IndicesOfMaxima, IndexVector);
+
+  /** Set the region over which the values will be computed */
+  void
+  SetRegion(const RegionType & region);
+
+  /** Get/Set the number of extreme intensity values to keep. */
+  itkGetConstMacro(N, SizeValueType);
+  itkSetMacro(N, SizeValueType);
+
+protected:
+  NMinimaMaximaImageCalculator();
+  ~NMinimaMaximaImageCalculator() override = default;
+  void
+  PrintSelf(std::ostream & os, Indent indent) const override;
+
+  template <typename TComparator = std::less<PixelType>>
+  void
+  SortedInsert(ValueVector &     vals,
+               IndexVector &     indices,
+               const PixelType & val,
+               const IndexType & ind,
+               TComparator       comp = TComparator());
+  void
+  InternalCompute();
+
+private:
+  ImageConstPointer m_Image;
+  ValueVector       m_Minima;
+  ValueVector       m_Maxima;
+  IndexVector       m_IndicesOfMinima;
+  IndexVector       m_IndicesOfMaxima;
+  SizeValueType     m_N{ 7 };
+
+  RegionType m_Region;
+  bool       m_RegionSetByUser{ false };
+  bool       m_ComputeMaxima{ true };
+  bool       m_ComputeMinima{ true };
+  std::mutex m_Mutex;
+};
+} // end namespace itk
+
+#ifndef ITK_MANUAL_INSTANTIATION
+#  include "itkNMinimaMaximaImageCalculator.hxx"
+#endif
+
+#endif /* itkNMinimaMaximaImageCalculator_h */