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
|
/*=========================================================================
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 otbRemoveIsolatedByDirectionFilter_h
#define otbRemoveIsolatedByDirectionFilter_h
#include "otbModulusAndDirectionImageToImageFilter.h"
#include "otbBinaryFunctorNeighborhoodImageFilter.h"
namespace otb
{
namespace Functor
{
/** \class RemoveIsolatedByDirectionFunctor
* \brief Binary neighborhood functor to remove isolated pixels by direction.
* Used by the RemoveIsolatedByDirectionFilter.
* \sa RemoveIsolatedByDirectionFilter
* \ingroup Functor
*
* \ingroup OTBRoadExtraction
*/
template <class TInput1, class TInput2, class TOutput>
class RemoveIsolatedByDirectionFunctor
{
public:
RemoveIsolatedByDirectionFunctor() {}
virtual ~RemoveIsolatedByDirectionFunctor() {}
inline TOutput operator ()(const TInput1& itA, const TInput2& itB)
{
double currentDirection = itB.GetCenterPixel();
int nEqualNeighbors = 0;
for (int neighborhoodIndex = 0; neighborhoodIndex < 9; ++neighborhoodIndex)
{
if (itB.GetPixel(neighborhoodIndex) == currentDirection)
{
++nEqualNeighbors;
}
}
if (nEqualNeighbors <= 1)
{
//should never be 0 as it is at least equal to itself
return 0;
}
else
{
return static_cast<TOutput>(itA.GetCenterPixel());
}
}
};
}
/** \class RemoveIsolatedByDirectionFilter
* \brief This filter removes (sets to null intensity) pixels isolated by direction.
*
* For a given pixel, the filter walk through its neighborhood in direction image, counting pixels having
* the same direction as the center pixel. If there is no such a pixel, the center pixel is considered to be
* isolated in direction, and thus will be removed (set to 0). If the pixel is not isolated in direction, the output
* value is the value of the pixel in the modulus image.
* Of course this filter requires the direction to be discrete, in order to be able to count the directions.
*
* \ingroup Streamed
* \ingroup Threaded
*
* \ingroup OTBRoadExtraction
*/
template <class TInputModulus, class TInputDirection, class TOutputImage>
class ITK_EXPORT RemoveIsolatedByDirectionFilter
: public ModulusAndDirectionImageToImageFilter<TInputModulus, TInputDirection, TOutputImage>
{
public:
/** Standard typedefs */
typedef RemoveIsolatedByDirectionFilter 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(RemoveIsolatedByDirectionFilter, 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::RemoveIsolatedByDirectionFunctor<
typename itk::ConstNeighborhoodIterator<TInputModulus>,
typename itk::ConstNeighborhoodIterator<TInputDirection>,
typename TOutputImage::PixelType> FunctorType;
typedef otb::BinaryFunctorNeighborhoodImageFilter<TInputModulus, TInputDirection, TOutputImage,
FunctorType> ComputingFilterType;
protected:
/** Constructor */
RemoveIsolatedByDirectionFilter() {};
/** Destructor */
~RemoveIsolatedByDirectionFilter() 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:
RemoveIsolatedByDirectionFilter(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
};
} // End namespace otb
#endif
|
