SourceXtractorPlusPlus  0.12
Please provide a description of the project.
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_background_rms(0),
42  m_detection_threshold(0),
43  m_variance_threshold(variance_threshold),
44  m_interpolation_gap(interpolation_gap) {}
45 
46 
47 template<typename T>
49  std::shared_ptr<CoordinateSystem> coordinate_system,
50  std::shared_ptr<WeightImage> variance_map
51 ):
52  m_image(detection_image),
53  m_variance_map(variance_map),
54  m_coordinate_system(coordinate_system),
55  m_gain(0),
56  m_saturation(0),
57  m_background_rms(0),
58  m_detection_threshold(0),
59  m_variance_threshold(1e6),
60  m_interpolation_gap(0) {
61  if (variance_map == nullptr && detection_image != nullptr) {
63  detection_image->getHeight(), .0001);
64  }
65 }
66 
67 template<typename T>
69  // FIXME replace switch with a better system
70  switch(layer) {
71  default:
72  case LayerOriginalImage:
73  return getOriginalImage();
74  break;
76  return getInterpolatedImage();
77  break;
79  return getSubtractedImage();
80  break;
81  case LayerFilteredImage:
82  return getFilteredImage();
83  break;
85  return getThresholdedImage();
86  break;
88  return getSnrImage();
89  break;
91  return getOriginalVarianceMap();
92  break;
94  return getUnfilteredVarianceMap();
95  break;
96  case LayerVarianceMap:
97  return getVarianceMap();
98  break;
100  return getDetectionThresholdMap();
101  break;
102  }
103 }
104 
105 template<typename T>
107  if (m_interpolation_gap > 0) {
108  if (m_interpolated_image == nullptr) {
109  const_cast<Frame<T> *>(this)->m_interpolated_image = BufferedImage<T>::create(
110  std::make_shared<InterpolatedImageSource<T >>(getOriginalImage(), getOriginalVarianceMap(),
111  getVarianceThreshold(), m_interpolation_gap)
112  );
113  }
114  return m_interpolated_image;
115  }
116  else {
117  return getOriginalImage();
118  }
119 }
120 
121 
122 template<typename T>
124  return SubtractImage<T>::create(getInterpolatedImage(), getBackgroundLevelMap());
125 }
126 
127 
128 template<typename T>
130  if (m_filtered_image == nullptr) {
131  const_cast<Frame<T> *>(this)->applyFilter();
132  }
133  return m_filtered_image;
134 }
135 
136 
137 template<typename T>
139  return ThresholdedImage<T>::create(getFilteredImage(), getVarianceMap(), m_detection_threshold);
140 }
141 
142 
143 template<typename T>
145  return SnrImage<T>::create(getFilteredImage(), getVarianceMap());
146 }
147 
148 
149 template<typename T>
151  if (m_filtered_variance_map == nullptr) {
152  const_cast<Frame<T> *>(this)->applyFilter();
153  }
154  return m_filtered_variance_map;
155 }
156 
157 
158 template<typename T>
160  if (m_interpolation_gap > 0) {
161  if (!m_interpolated_variance) {
162  const_cast<Frame *>(this)->m_interpolated_variance = BufferedImage<WeightImage::PixelType>::create(
164  getVarianceThreshold(), m_interpolation_gap)
165  );
166  }
167  return m_interpolated_variance;
168  }
169  else {
170  return m_variance_map;
171  }
172 }
173 
174 
175 template<typename T>
177  struct ThresholdOperation {
178  static T process(const T& a, const T& b) { return sqrt(a) * b; }
179  };
180 
181  using ThresholdImage = ProcessedImage<T, ThresholdOperation>;
182  return ThresholdImage::create(m_variance_map, m_detection_threshold);
183 }
184 
185 
186 template<typename T>
188  m_variance_map = variance_map;
189 
190  // resets the interpolated image cache and filtered image
191  m_interpolated_image = nullptr;
192  m_filtered_image = nullptr;
193  m_filtered_variance_map = nullptr;
194 }
195 
196 
197 template<typename T>
199  m_variance_threshold = threshold;
200 
201  // resets the interpolated image cache and filtered image
202  m_interpolated_image = nullptr;
203  m_filtered_image = nullptr;
204  m_filtered_variance_map = nullptr;
205 }
206 
207 
208 template<typename T>
210  if (m_background_level_map != nullptr) {
211  return m_background_level_map;
212  }
213  else {
214  // background level = 0 by default
215  return ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), 0);
216  }
217 }
218 
219 
220 template<typename T>
221 void Frame<T>::setDetectionThreshold(T detection_threshold) {
222  m_detection_threshold = detection_threshold;
223 }
224 
225 
226 template<typename T>
227 void Frame<T>::setBackgroundLevel(T background_level) {
228  setBackgroundLevel(ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), background_level), 0.);
229 }
230 
231 
232 template<typename T>
233 void Frame<T>::setBackgroundLevel(std::shared_ptr<Image<T>> background_level_map, T background_rms) {
234  m_background_level_map = background_level_map;
235  m_background_rms = background_rms;
236  m_filtered_image = nullptr;
237 }
238 
239 
240 template<typename T>
242  m_filter = filter;
243  m_filtered_image = nullptr;
244  m_filtered_variance_map = nullptr;
245 }
246 
247 
248 template<typename T>
249 void Frame<T>::setLabel(const std::string& label) {
250  m_label = label;
251 }
252 
253 
254 template<typename T>
256  if (m_filter != nullptr) {
257  m_filtered_image = m_filter->processImage(getSubtractedImage(), getUnfilteredVarianceMap(), getVarianceThreshold());
258  auto filtered_variance_map = m_filter->processImage(getUnfilteredVarianceMap(), getUnfilteredVarianceMap(),
259  getVarianceThreshold());
260  m_filtered_variance_map = FunctionalImage<T>::create(
261  m_filtered_image->getWidth(), m_filtered_image->getHeight(),
262  [filtered_variance_map](int x, int y) -> T {
263  return std::max(filtered_variance_map->getValue(x, y), 0.f);
264  }
265  );
266 
267  }
268  else {
269  m_filtered_image = getSubtractedImage();
270  m_filtered_variance_map = getUnfilteredVarianceMap();
271  }
272 }
273 
274 
275 template
276 class Frame<SeFloat>;
277 
278 } // end namespace SourceXtractor
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)
static std::shared_ptr< ImageBase< T > > create(Args &&... args)
std::shared_ptr< Image< T > > getInterpolatedImage() const
Definition: Frame.cpp:106
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > x
std::shared_ptr< Image< T > > getSnrImage() const
Definition: Frame.cpp:144
std::shared_ptr< WeightImage > getVarianceMap() const
Definition: Frame.cpp:150
SeFloat32 SeFloat
Definition: Types.h:32
std::shared_ptr< WeightImage > m_variance_map
Definition: Frame.h:169
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > y
std::shared_ptr< Image< T > > getImage(FrameImageLayer layer) const
Definition: Frame.cpp:68
STL class.
std::shared_ptr< WeightImage > getUnfilteredVarianceMap() const
Definition: Frame.cpp:159
std::shared_ptr< Image< T > > getBackgroundLevelMap() const
Definition: Frame.cpp:209
void setVarianceThreshold(WeightImage::PixelType threshold)
Definition: Frame.cpp:198
void setLabel(const std::string &label)
Definition: Frame.cpp:249
T max(T... args)
void setVarianceMap(std::shared_ptr< WeightImage > variance_map)
Definition: Frame.cpp:187
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:221
std::shared_ptr< Image< T > > getThresholdedImage() const
Definition: Frame.cpp:138
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:241
std::shared_ptr< Image< T > > getSubtractedImage() const
Definition: Frame.cpp:123
void setBackgroundLevel(T background_level)
Definition: Frame.cpp:227
std::shared_ptr< Image< T > > getDetectionThresholdMap() const
Definition: Frame.cpp:176
Processes two images to create a third combining them by using any function.
std::shared_ptr< Image< T > > getFilteredImage() const
Definition: Frame.cpp:129
static std::shared_ptr< ProcessedImage< T, P > > create(std::shared_ptr< const Image< T >> image_a, std::shared_ptr< const Image< T >> image_b)