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
|
/*=========================================================================
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 otbRemoveWrongDirectionFilter_h
#define otbRemoveWrongDirectionFilter_h
#include "otbModulusAndDirectionImageToImageFilter.h"
#include "itkBinaryFunctorImageFilter.h"
#include "otbMath.h"
namespace otb
{
namespace Functor
{
/** \class RemoveWrongDirectionFunctor
* \brief This functor is used by the RemoveWrongDirectionFilter
*
* \sa RemoveWrongDirectionFilter
* \ingroup Functor
*
* \example FeatureExtraction/ExtractRoadByStepsExample.cxx
*
*
* \ingroup OTBRoadExtraction
*/
template <class TInput1, class TInput2, class TOutput>
class RemoveWrongDirectionFunctor
{
public:
RemoveWrongDirectionFunctor() {}
virtual ~RemoveWrongDirectionFunctor() {}
inline TOutput operator ()(const TInput1& A, const TInput2& B)
{
if (B < CONST_PI_8)
{
return 0;
}
else
{
return A;
}
}
};
}
/** \class RemoveWrongDirectionFilter
* \brief This filter removes (sets to null intensity) pixels with wrong direction.
*
* This filter is part of the road extraction framework. By using the Spectral Angle filter,
* we can assume that the direction of a road on our scalar product image is positive (greater
* than \f$ \pi/8 \f$).
* Therefore in the input modulus and direction images, pixels whose direction is lower than
* this threshold are suppressed
* (in fact, their intensity is set to 0).
*
* \sa NeighborhoodScalarProductFilter
* \ingroup Streamed
* \ingroup Threaded
*
* \ingroup OTBRoadExtraction
*/
template <class TInputModulus, class TInputDirection, class TOutputImage>
class ITK_EXPORT RemoveWrongDirectionFilter
: public ModulusAndDirectionImageToImageFilter<TInputModulus, TInputDirection, TOutputImage>
{
public:
/** Standard typedefs */
typedef RemoveWrongDirectionFilter 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(RemoveWrongDirectionFilter, ModulusAndDirectionImageToImageFilter);
/** typedef of the computing filter (this allows us to derive from ModulusAndDirectionToImageFilter as well as
using the BinaryFunctorImageFilter, which is appropriate here */
typedef Functor::RemoveWrongDirectionFunctor<
typename TInputModulus::PixelType,
typename TInputDirection::PixelType,
typename TOutputImage::PixelType> FunctorType;
typedef itk::BinaryFunctorImageFilter<TInputModulus, TInputDirection, TOutputImage, FunctorType> ComputingFilterType;
protected:
/** Constructor */
RemoveWrongDirectionFilter() {};
/** Destructor */
~RemoveWrongDirectionFilter() 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:
RemoveWrongDirectionFilter(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
};
} // End namespace otb
#endif
|
