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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef otbNonMaxRemovalByDirectionFilter_h
#define otbNonMaxRemovalByDirectionFilter_h
#include "otbModulusAndDirectionImageToImageFilter.h"
#include "otbBinaryFunctorNeighborhoodImageFilter.h"
#include "otbMath.h"
namespace otb
{
namespace Functor
{
/** \class NonMaxRemovalByDirectionFunctor
* \brief This functor is used by the NonMaxRemovalByDirectionFilter
* \sa NonMaxRemovalByDirectionFilter
* \ingroup Functor
*
* \ingroup OTBRoadExtraction
*/
template <class TInput1, class TInput2, class TOutput>
class NonMaxRemovalByDirectionFunctor
{
public:
NonMaxRemovalByDirectionFunctor() {}
virtual ~NonMaxRemovalByDirectionFunctor() {}
inline TOutput operator ()(const TInput1& itA, const TInput2& itB)
{
TOutput resp = 0;
if (itA.GetCenterPixel() != 0)
{
typename TInput1::OffsetType offset1, offset2;
offset1.Fill(0);
offset2.Fill(0);
int neighborhoodNumber;
if (itB.GetCenterPixel() > 0)
{
neighborhoodNumber = static_cast<int>(itB.GetCenterPixel() / (CONST_PI_4) -1);
}
else
{
neighborhoodNumber = static_cast<int>((itB.GetCenterPixel() + CONST_PI) / (CONST_PI_4) -1);
}
switch (neighborhoodNumber)
{
case 0:
offset1[0] = 1;
offset1[1] = -1;
offset2[0] = -1;
offset2[1] = 1;
break;
case 1:
offset1[0] = 1;
offset1[1] = 0;
offset2[0] = -1;
offset2[1] = 0;
break;
case 2:
offset1[0] = 1;
offset1[1] = 1;
offset2[0] = -1;
offset2[1] = -1;
break;
case 3:
offset1[0] = 0;
offset1[1] = 1;
offset2[0] = 0;
offset2[1] = -1;
break;
}
if ((itA.GetCenterPixel() > itA.GetPixel(offset1))
&& (itA.GetCenterPixel() > itA.GetPixel(offset2)))
{
resp = itA.GetCenterPixel();
}
}
return resp;
}
};
}
/** \class NonMaxRemovalByDirectionFilter
* \brief This filters removes (sets to null intensity) pixels which are not the maxima of the
* scalar product modulus value in the given direction.
*
* \ingroup Streamed
* \ingroup Threaded
*
* \ingroup OTBRoadExtraction
*/
template <class TInputModulus, class TInputDirection, class TOutputImage>
class ITK_EXPORT NonMaxRemovalByDirectionFilter
: public ModulusAndDirectionImageToImageFilter<TInputModulus, TInputDirection, TOutputImage>
{
public:
/** Standard typedefs */
typedef NonMaxRemovalByDirectionFilter Self;
typedef ModulusAndDirectionImageToImageFilter<TInputModulus, TInputDirection, TOutputImage> Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Type macro */
itkNewMacro(Self);
/** Creation through object factory macro */
itkTypeMacro(NonMaxRemovalByDirectionFilter, ModulusAndDirectionImageToImageFilter);
/** typedef of the computing filter (this allows us to derive from ModulusAndDirectionToImageFilter as well as
using the BinaryFunctorNeighBorhoodImageFilter, which is appropriate here */
typedef Functor::NonMaxRemovalByDirectionFunctor<
typename itk::ConstNeighborhoodIterator<TInputModulus>,
typename itk::ConstNeighborhoodIterator<TInputDirection>,
typename TOutputImage::PixelType> FunctorType;
typedef otb::BinaryFunctorNeighborhoodImageFilter<TInputModulus, TInputDirection, TOutputImage,
FunctorType> ComputingFilterType;
protected:
/** Constructor */
NonMaxRemovalByDirectionFilter() {};
/** Destructor */
~NonMaxRemovalByDirectionFilter() ITK_OVERRIDE {}
/**PrintSelf method */
void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE
{
Superclass::PrintSelf(os, indent);
}
/** Main computation method */
void GenerateData(void) ITK_OVERRIDE
{
typename ComputingFilterType::Pointer filter = ComputingFilterType::New();
filter->SetInput1(this->GetInput());
filter->SetInput2(this->GetInputDirection());
filter->GraftOutput(this->GetOutput());
filter->Update();
this->GraftOutput(filter->GetOutput());
}
private:
NonMaxRemovalByDirectionFilter(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
};
} // End namespace otb
#endif
|
