1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*=========================================================================
*
* 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 itkMinimumMaximumImageCalculator_h
#define itkMinimumMaximumImageCalculator_h
#include "itkNumericTraits.h"
#include "itkObject.h"
#include "itkObjectFactory.h"
namespace itk
{
/** \class MinimumMaximumImageCalculator
* \brief Computes the minimum and the maximum intensity values of
* an image.
*
* This calculator computes the minimum and the maximum intensity values of
* an image. It is templated over input image type. If only Maximum or
* Minimum value is needed, just call ComputeMaximum() (ComputeMinimum())
* otherwise Compute() will compute both.
*
* \ingroup Operators
* \ingroup ITKCommon
*
* \sphinx
* \sphinxexample{Core/Common/FindMaxAndMinInImage,Find Max And Min In Image}
* \sphinxexample{Core/Common/MultiThreadOilPainting,Multi-thread Oil Painting}
* \endsphinx
*/
template <typename TInputImage>
class ITK_TEMPLATE_EXPORT MinimumMaximumImageCalculator : public Object
{
public:
ITK_DISALLOW_COPY_AND_MOVE(MinimumMaximumImageCalculator);
/** Standard class type aliases. */
using Self = MinimumMaximumImageCalculator;
using Superclass = Object;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(MinimumMaximumImageCalculator);
/** 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;
/** 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;
/** Set the input image. */
itkSetConstObjectMacro(Image, ImageType);
/** Compute the minimum value of intensity of the input image. */
void
ComputeMinimum();
/** Compute the maximum value of intensity of the input image. */
void
ComputeMaximum();
/** Compute the minimum and maximum values of intensity of the input image. */
void
Compute();
/** Return the minimum intensity value. */
itkGetConstMacro(Minimum, PixelType);
/** Return the maximum intensity value. */
itkGetConstMacro(Maximum, PixelType);
/** Return the index of the minimum intensity value. */
itkGetConstReferenceMacro(IndexOfMinimum, IndexType);
/** Return the index of the maximum intensity value. */
itkGetConstReferenceMacro(IndexOfMaximum, IndexType);
/** Set the region over which the values will be computed */
void
SetRegion(const RegionType & region);
protected:
MinimumMaximumImageCalculator() = default;
~MinimumMaximumImageCalculator() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
private:
PixelType m_Minimum{ NumericTraits<PixelType>::max() };
PixelType m_Maximum{ NumericTraits<PixelType>::NonpositiveMin() };
ImageConstPointer m_Image{ TInputImage::New() };
IndexType m_IndexOfMinimum{};
IndexType m_IndexOfMaximum{};
RegionType m_Region{};
bool m_RegionSetByUser{};
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkMinimumMaximumImageCalculator.hxx"
#endif
#endif /* itkMinimumMaximumImageCalculator_h */
|
