SourceXtractorPlusPlus  0.10
Please provide a description of the project.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Frame.cpp
Go to the documentation of this file.
1 
25 
26 
27 namespace SourceXtractor {
28 
29 template<typename T>
31  std::shared_ptr<WeightImage> variance_map,
32  WeightImage::PixelType variance_threshold,
33  std::shared_ptr<CoordinateSystem> coordinate_system,
34  SeFloat gain, SeFloat saturation, int interpolation_gap
35 ):
36  m_image(detection_image),
37  m_variance_map(variance_map),
38  m_coordinate_system(coordinate_system),
39  m_gain(gain),
40  m_saturation(saturation),
41  m_detection_threshold(0),
42  m_variance_threshold(variance_threshold),
43  m_interpolation_gap(interpolation_gap) {}
44 
45 
46 template<typename T>
48  std::shared_ptr<CoordinateSystem> coordinate_system,
49  std::shared_ptr<WeightImage> variance_map
50 ):
51  m_image(detection_image),
52  m_variance_map(variance_map),
53  m_coordinate_system(coordinate_system),
54  m_gain(0),
55  m_saturation(0),
56  m_detection_threshold(0),
57  m_variance_threshold(1e6),
58  m_interpolation_gap(0) {
59  if (variance_map == nullptr && detection_image != nullptr) {
61  detection_image->getHeight(), .0001);
62  }
63 }
64 
65 
66 template<typename T>
68  if (m_interpolation_gap > 0) {
69  if (m_interpolated_image == nullptr) {
70  const_cast<Frame<T> *>(this)->m_interpolated_image = BufferedImage<T>::create(
71  std::make_shared<InterpolatedImageSource<T >>(getOriginalImage(), getOriginalVarianceMap(),
72  getVarianceThreshold(), m_interpolation_gap)
73  );
74  }
75  return m_interpolated_image;
76  }
77  else {
78  return getOriginalImage();
79  }
80 }
81 
82 
83 template<typename T>
85  return SubtractImage<T>::create(getInterpolatedImage(), getBackgroundLevelMap());
86 }
87 
88 
89 template<typename T>
91  if (m_filtered_image == nullptr) {
92  const_cast<Frame<T> *>(this)->applyFilter();
93  }
94  return m_filtered_image;
95 }
96 
97 
98 template<typename T>
100  return ThresholdedImage<T>::create(getFilteredImage(), getVarianceMap(), m_detection_threshold);
101 }
102 
103 
104 template<typename T>
106  return SnrImage<T>::create(getFilteredImage(), getVarianceMap());
107 }
108 
109 
110 template<typename T>
112  if (m_filtered_variance_map == nullptr) {
113  const_cast<Frame<T> *>(this)->applyFilter();
114  }
115  return m_filtered_variance_map;
116 }
117 
118 
119 template<typename T>
121  if (m_interpolation_gap > 0) {
122  if (!m_interpolated_variance) {
123  const_cast<Frame *>(this)->m_interpolated_variance = BufferedImage<WeightImage::PixelType>::create(
125  getVarianceThreshold(), m_interpolation_gap)
126  );
127  }
128  return m_interpolated_variance;
129  }
130  else {
131  return m_variance_map;
132  }
133 }
134 
135 
136 template<typename T>
138  struct ThresholdOperation {
139  static T process(const T& a, const T& b) { return sqrt(a) * b; }
140  };
141 
142  using ThresholdImage = ProcessedImage<T, ThresholdOperation>;
143  return ThresholdImage::create(m_variance_map, m_detection_threshold);
144 }
145 
146 
147 template<typename T>
149  m_variance_map = variance_map;
150 
151  // resets the interpolated image cache and filtered image
152  m_interpolated_image = nullptr;
153  m_filtered_image = nullptr;
154  m_filtered_variance_map = nullptr;
155 }
156 
157 
158 template<typename T>
160  m_variance_threshold = threshold;
161 
162  // resets the interpolated image cache and filtered image
163  m_interpolated_image = nullptr;
164  m_filtered_image = nullptr;
165  m_filtered_variance_map = nullptr;
166 }
167 
168 
169 template<typename T>
171  if (m_background_level_map != nullptr) {
172  return m_background_level_map;
173  }
174  else {
175  // background level = 0 by default
176  return ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), 0);
177  }
178 }
179 
180 
181 template<typename T>
182 void Frame<T>::setDetectionThreshold(T detection_threshold) {
183  m_detection_threshold = detection_threshold;
184 }
185 
186 
187 template<typename T>
188 void Frame<T>::setBackgroundLevel(T background_level) {
189  setBackgroundLevel(ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), background_level));
190 }
191 
192 
193 template<typename T>
195  m_background_level_map = background_level_map;
196  m_filtered_image = nullptr;
197 }
198 
199 
200 template<typename T>
202  m_filter = filter;
203  m_filtered_image = nullptr;
204  m_filtered_variance_map = nullptr;
205 }
206 
207 
208 template<typename T>
209 void Frame<T>::setLabel(const std::string& label) {
210  m_label = label;
211 }
212 
213 
214 template<typename T>
216  if (m_filter != nullptr) {
217  m_filtered_image = m_filter->processImage(getSubtractedImage(), getUnfilteredVarianceMap(), getVarianceThreshold());
218  auto filtered_variance_map = m_filter->processImage(getUnfilteredVarianceMap(), getUnfilteredVarianceMap(),
219  getVarianceThreshold());
220  m_filtered_variance_map = FunctionalImage<T>::create(
221  m_filtered_image->getWidth(), m_filtered_image->getHeight(),
222  [filtered_variance_map](int x, int y) -> T {
223  return std::max(filtered_variance_map->getValue(x, y), 0.f);
224  }
225  );
226 
227  }
228  else {
229  m_filtered_image = getSubtractedImage();
230  m_filtered_variance_map = getUnfilteredVarianceMap();
231  }
232 }
233 
234 
235 template
236 class Frame<SeFloat>;
237 
238 } // end namespace SourceXtractor
std::shared_ptr< Image< T > > getSnrImage() const
Definition: Frame.cpp:105
static std::shared_ptr< ThresholdedImage< T > > create(std::shared_ptr< const Image< T >> image, std::shared_ptr< const Image< T >> variance_map, T threshold_multiplier)
std::shared_ptr< Image< T > > getThresholdedImage() const
Definition: Frame.cpp:99
std::shared_ptr< WeightImage > getVarianceMap() const
Definition: Frame.cpp:111
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > x
std::shared_ptr< Image< T > > getBackgroundLevelMap() const
Definition: Frame.cpp:170
SeFloat32 SeFloat
Definition: Types.h:32
std::shared_ptr< WeightImage > getUnfilteredVarianceMap() const
Definition: Frame.cpp:120
static std::shared_ptr< ImageBase< T > > create(Args &&...args)
std::shared_ptr< Image< T > > getDetectionThresholdMap() const
Definition: Frame.cpp:137
std::shared_ptr< WeightImage > m_variance_map
Definition: Frame.h:148
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > y
STL class.
std::shared_ptr< Image< T > > getFilteredImage() const
Definition: Frame.cpp:90
std::shared_ptr< Image< T > > getSubtractedImage() const
Definition: Frame.cpp:84
void setVarianceThreshold(WeightImage::PixelType threshold)
Definition: Frame.cpp:159
void setLabel(const std::string &label)
Definition: Frame.cpp:209
T max(T...args)
void setVarianceMap(std::shared_ptr< WeightImage > variance_map)
Definition: Frame.cpp:148
Frame(std::shared_ptr< Image< T >> detection_image, std::shared_ptr< WeightImage > variance_map, WeightImage::PixelType variance_threshold, std::shared_ptr< CoordinateSystem > coordinate_system, SeFloat gain, SeFloat saturation, int interpolation_gap)
Definition: Frame.cpp:30
T make_shared(T...args)
void setDetectionThreshold(T detection_threshold)
Definition: Frame.cpp:182
static std::shared_ptr< ConstantImage< T > > create(int width, int height, T constant_value)
Definition: ConstantImage.h:42
Interface representing an image.
Definition: Image.h:43
T sqrt(T...args)
void setFilter(std::shared_ptr< ImageFilter > filter)
Definition: Frame.cpp:201
void setBackgroundLevel(T background_level)
Definition: Frame.cpp:188
std::shared_ptr< Image< T > > getInterpolatedImage() const
Definition: Frame.cpp:67
Processes two images to create a third combining them by using any function.
static std::shared_ptr< ProcessedImage< T, P > > create(std::shared_ptr< const Image< T >> image_a, std::shared_ptr< const Image< T >> image_b)