1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*=========================================================================
*
* 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 itkMatrixIndexSelectionImageFilter_h
#define itkMatrixIndexSelectionImageFilter_h
#include "itkUnaryFunctorImageFilter.h"
namespace itk
{
namespace Functor
{
template <typename TInput, typename TOutput>
class MatrixIndexSelection
{
public:
MatrixIndexSelection() { m_I = m_J = 0; }
~MatrixIndexSelection() = default;
void
GetIndices(unsigned int & i, unsigned int & j) const
{
i = m_I;
j = m_J;
}
void
SetIndices(unsigned int i, unsigned int j)
{
m_I = i;
m_J = j;
}
bool
operator==(const MatrixIndexSelection & other) const
{
return m_I == other.m_I && m_J == other.m_J;
}
ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(MatrixIndexSelection);
inline TOutput
operator()(const TInput & A) const
{
return static_cast<TOutput>(A[m_I][m_J]);
}
private:
unsigned int m_I;
unsigned int m_J;
};
} // namespace Functor
/** \class MatrixIndexSelectionImageFilter
*
* \brief Extracts the selected indices of a matrix image that is the input
* pixel type
*
* This filter is templated over the input image type and
* output image type.
*
* The filter expect the input image pixel type to be a matrix and
* the output image pixel type to be a scalar. The only requirement on
* the type used for representing the vector is that it must provide an
* operator(i,j).
*
* \ingroup IntensityImageFilters MultiThreaded
* \ingroup ITKImageIntensity
*/
template <typename TInputImage, typename TOutputImage>
class MatrixIndexSelectionImageFilter
: public UnaryFunctorImageFilter<
TInputImage,
TOutputImage,
Functor::MatrixIndexSelection<typename TInputImage::PixelType, typename TOutputImage::PixelType>>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(MatrixIndexSelectionImageFilter);
/** Standard class type aliases. */
using Self = MatrixIndexSelectionImageFilter<Image<Matrix<unsigned short, 2, 2>, 2>, Image<unsigned char, 2>>;
using Superclass = UnaryFunctorImageFilter<
TInputImage,
TOutputImage,
Functor::MatrixIndexSelection<typename TInputImage::PixelType, typename TOutputImage::PixelType>>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(MatrixIndexSelectionImageFilter);
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Get/Set methods for the index */
void
SetIndices(unsigned int i, unsigned int j)
{
this->GetFunctor().SetIndices(i, j);
this->Modified();
}
void
GetIndices(unsigned int & i, unsigned int & j) const
{
return this->GetFunctor().GetIndices(i, j);
}
#ifdef ITK_USE_CONCEPT_CHECKING
// Begin concept checking
itkConceptMacro(InputHasNumericTraitsCheck, (Concept::HasNumericTraits<typename TInputImage::PixelType::ValueType>));
// End concept checking
#endif
protected:
MatrixIndexSelectionImageFilter() = default;
~MatrixIndexSelectionImageFilter() override = default;
};
} // end namespace itk
#endif
|
