SourceXtractorPlusPlus  0.15
Please provide a description of the project.
Frame.cpp
Go to the documentation of this file.
1 
26 
27 
28 namespace SourceXtractor {
29 
30 template<typename T>
32  std::shared_ptr<WeightImage> variance_map,
33  WeightImage::PixelType variance_threshold,
34  std::shared_ptr<CoordinateSystem> coordinate_system,
35  SeFloat gain, SeFloat saturation, int interpolation_gap
36 ):
37  m_image(detection_image),
38  m_variance_map(variance_map),
39  m_coordinate_system(coordinate_system),
40  m_gain(gain),
41  m_saturation(saturation),
42  m_background_rms(0),
43  m_detection_threshold(0),
44  m_variance_threshold(variance_threshold),
45  m_interpolation_gap(interpolation_gap) {
47  applyFilter();
48 }
49 
50 
51 template<typename T>
53  std::shared_ptr<CoordinateSystem> coordinate_system,
54  std::shared_ptr<WeightImage> variance_map
55 ):
56  m_image(detection_image),
57  m_variance_map(variance_map),
58  m_coordinate_system(coordinate_system),
59  m_gain(0),
60  m_saturation(0),
61  m_background_rms(0),
62  m_detection_threshold(0),
63  m_variance_threshold(1e6),
64  m_interpolation_gap(0) {
65  if (variance_map == nullptr && detection_image != nullptr) {
67  detection_image->getHeight(), .0001);
68  }
70  applyFilter();
71 }
72 
73 template<typename T>
75  // FIXME replace switch with a better system
76  switch(layer) {
77  default:
78  case LayerOriginalImage:
79  return getOriginalImage();
80  break;
82  return getInterpolatedImage();
83  break;
85  return getSubtractedImage();
86  break;
87  case LayerFilteredImage:
88  return getFilteredImage();
89  break;
91  return getThresholdedImage();
92  break;
94  return getSnrImage();
95  break;
97  return getOriginalVarianceMap();
98  break;
100  return getUnfilteredVarianceMap();
101  break;
102  case LayerVarianceMap:
103  return getVarianceMap();
104  break;
106  return getDetectionThresholdMap();
107  break;
108  }
109 }
110 
111 template<typename T>
113  if (m_interpolated_image > 0) {
114  return m_interpolated_image;
115  }
116  else {
117  return m_image;
118  }
119 }
120 
121 
122 template<typename T>
124  return SubtractImage<T>::create(getInterpolatedImage(), getBackgroundLevelMap());
125 }
126 
127 
128 template<typename T>
130  return m_filtered_image;
131 }
132 
133 
134 template<typename T>
136  return ThresholdedImage<T>::create(getFilteredImage(), getVarianceMap(), m_detection_threshold);
137 }
138 
139 
140 template<typename T>
142  return SnrImage<T>::create(getFilteredImage(), getVarianceMap());
143 }
144 
145 
146 template<typename T>
148  return m_filtered_variance_map;
149 }
150 
151 
152 template<typename T>
154  if (m_interpolated_variance) {
155  return m_interpolated_variance;
156  }
157  else {
158  return m_variance_map;
159  }
160 }
161 
162 
163 template<typename T>
165  struct ThresholdOperation {
166  static T process(const T& a, const T& b) { return sqrt(a) * b; }
167  };
168 
169  using ThresholdImage = ProcessedImage<T, ThresholdOperation>;
170  return ThresholdImage::create(m_variance_map, m_detection_threshold);
171 }
172 
173 
174 template<typename T>
176  m_variance_map = variance_map;
177 
178  // resets the interpolated image cache and filtered image
179  m_interpolated_image = nullptr;
180  m_interpolated_variance = nullptr;
181  m_filtered_image = nullptr;
182  m_filtered_variance_map = nullptr;
183 
184  applyInterpolation();
185  applyFilter();
186 }
187 
188 
189 template<typename T>
191  m_variance_threshold = threshold;
192 
193  // resets the interpolated image cache and filtered image
194  m_interpolated_image = nullptr;
195  m_interpolated_variance = nullptr;
196  m_filtered_image = nullptr;
197  m_filtered_variance_map = nullptr;
198 
199  applyInterpolation();
200  applyFilter();
201 }
202 
203 
204 template<typename T>
206  if (m_background_level_map != nullptr) {
207  return m_background_level_map;
208  }
209  else {
210  // background level = 0 by default
211  return ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), 0);
212  }
213 }
214 
215 
216 template<typename T>
217 void Frame<T>::setDetectionThreshold(T detection_threshold) {
218  m_detection_threshold = detection_threshold;
219 }
220 
221 
222 template<typename T>
223 void Frame<T>::setBackgroundLevel(T background_level) {
224  setBackgroundLevel(ConstantImage<T>::create(m_image->getWidth(), m_image->getHeight(), background_level), 0.);
225 }
226 
227 
228 template<typename T>
229 void Frame<T>::setBackgroundLevel(std::shared_ptr<Image<T>> background_level_map, T background_rms) {
230  m_background_level_map = background_level_map;
231  m_background_rms = background_rms;
232  m_filtered_image = nullptr;
233  m_filtered_variance_map = nullptr;
234 
235  applyFilter();
236 }
237 
238 
239 template<typename T>
241  m_filter = filter;
242  m_filtered_image = nullptr;
243  m_filtered_variance_map = nullptr;
244  applyFilter();
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(),
258  m_variance_threshold);
259  auto filtered_variance_map = m_filter->processImage(getUnfilteredVarianceMap(),
260  getUnfilteredVarianceMap(),
261  m_variance_threshold);
262  m_filtered_variance_map = FunctionalImage<T>::create(
263  filtered_variance_map, [](int, int, WeightImage::PixelType v) {
264  return std::max(v, 0.f);
265  }
266  );
267  }
268  else {
269  m_filtered_image = getSubtractedImage();
270  m_filtered_variance_map = getUnfilteredVarianceMap();
271  }
272 }
273 
274 template<typename T>
276  if (!m_interpolated_variance) {
277  m_interpolated_variance = BufferedImage<WeightImage::PixelType>::create(
279  m_variance_map, m_variance_map, m_variance_threshold, m_interpolation_gap)
280  );
281  }
282  if (!m_interpolated_image) {
283  m_interpolated_image = BufferedImage<T>::create(
285  m_image, m_variance_map, m_variance_threshold, m_interpolation_gap)
286  );
287  }
288 }
289 
290 template
291 class Frame<SeFloat>;
292 
293 } // end namespace SourceXtractor
SourceXtractor::LayerOriginalImage
@ LayerOriginalImage
Definition: Frame.h:36
SourceXtractor::ConstantImage
Definition: ConstantImage.h:33
SourceXtractor::Frame::getSubtractedImage
std::shared_ptr< Image< T > > getSubtractedImage() const
Definition: Frame.cpp:123
std::string
STL class.
SourceXtractor::Frame::getVarianceMap
std::shared_ptr< WeightImage > getVarianceMap() const
Definition: Frame.cpp:147
std::shared_ptr
STL class.
SourceXtractor::Frame::getSnrImage
std::shared_ptr< Image< T > > getSnrImage() const
Definition: Frame.cpp:141
SourceXtractor::Frame::getFilteredImage
std::shared_ptr< Image< T > > getFilteredImage() const
Definition: Frame.cpp:129
SourceXtractor::Frame
Definition: Frame.h:49
SourceXtractor::Image::PixelType
T PixelType
Definition: Image.h:47
ConstantImage.h
SourceXtractor::InterpolatedImageSource
Definition: InterpolatedImageSource.h:35
SourceXtractor::LayerUnfilteredVarianceMap
@ LayerUnfilteredVarianceMap
Definition: Frame.h:43
SourceXtractor::SeFloat
SeFloat32 SeFloat
Definition: Types.h:32
std::make_shared
T make_shared(T... args)
SourceXtractor::ProcessedImage
Processes two images to create a third combining them by using any function.
Definition: ProcessedImage.h:36
SourceXtractor::Frame::getInterpolatedImage
std::shared_ptr< Image< T > > getInterpolatedImage() const
Definition: Frame.cpp:112
SourceXtractor::LayerVarianceMap
@ LayerVarianceMap
Definition: Frame.h:44
SourceXtractor::LayerFilteredImage
@ LayerFilteredImage
Definition: Frame.h:39
SourceXtractor::Image
Interface representing an image.
Definition: Image.h:43
SourceXtractor::FrameImageLayer
FrameImageLayer
Definition: Frame.h:35
SourceXtractor::BufferedImage::create
static std::shared_ptr< BufferedImage< T > > create(std::shared_ptr< const ImageSource > source, std::shared_ptr< TileManager > tile_manager=TileManager::getInstance())
Definition: BufferedImage.cpp:32
std::sqrt
T sqrt(T... args)
SourceXtractor::ThresholdedImage::create
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)
Definition: ThresholdedImage.h:58
SourceXtractor::LayerSignalToNoiseMap
@ LayerSignalToNoiseMap
Definition: Frame.h:41
SourceXtractor::Frame::applyInterpolation
void applyInterpolation()
Definition: Frame.cpp:275
SourceXtractor
Definition: Aperture.h:30
SourceXtractor::Frame::getBackgroundLevelMap
std::shared_ptr< Image< T > > getBackgroundLevelMap() const
Definition: Frame.cpp:205
SourceXtractor::FunctionalImage::create
static std::shared_ptr< FunctionalImage< T, I > > create(Args &&... args)
Definition: FunctionalImage.h:56
SourceXtractor::Frame::m_variance_map
std::shared_ptr< WeightImage > m_variance_map
Definition: Frame.h:165
BufferedImage.h
SourceXtractor::LayerOriginalVarianceMap
@ LayerOriginalVarianceMap
Definition: Frame.h:42
SourceXtractor::Frame::getImage
std::shared_ptr< Image< T > > getImage(FrameImageLayer layer) const
Definition: Frame.cpp:74
SourceXtractor::LayerDetectionThresholdMap
@ LayerDetectionThresholdMap
Definition: Frame.h:45
FunctionalImage.h
ThresholdedImage.h
SourceXtractor::ConstantImage::create
static std::shared_ptr< ConstantImage< T > > create(int width, int height, T constant_value)
Definition: ConstantImage.h:42
ProcessedImage.h
SourceXtractor::Frame::Frame
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:31
SourceXtractor::Frame::applyFilter
void applyFilter()
Definition: Frame.cpp:255
Frame.h
SourceXtractor::Frame::getUnfilteredVarianceMap
std::shared_ptr< WeightImage > getUnfilteredVarianceMap() const
Definition: Frame.cpp:153
SourceXtractor::Frame::getThresholdedImage
std::shared_ptr< Image< T > > getThresholdedImage() const
Definition: Frame.cpp:135
SourceXtractor::ProcessedImage::create
static std::shared_ptr< ProcessedImage< T, P > > create(std::shared_ptr< const Image< T >> image_a, std::shared_ptr< const Image< T >> image_b)
Definition: ProcessedImage.h:53
SourceXtractor::LayerInterpolatedImage
@ LayerInterpolatedImage
Definition: Frame.h:37
SourceXtractor::Frame::setVarianceThreshold
void setVarianceThreshold(WeightImage::PixelType threshold)
Definition: Frame.cpp:190
SourceXtractor::Frame::setLabel
void setLabel(const std::string &label)
Definition: Frame.cpp:249
SourceXtractor::Frame::setVarianceMap
void setVarianceMap(std::shared_ptr< WeightImage > variance_map)
Definition: Frame.cpp:175
SourceXtractor::Frame::setFilter
void setFilter(std::shared_ptr< ImageFilter > filter)
Definition: Frame.cpp:240
SourceXtractor::Frame::setDetectionThreshold
void setDetectionThreshold(T detection_threshold)
Definition: Frame.cpp:217
SourceXtractor::LayerSubtractedImage
@ LayerSubtractedImage
Definition: Frame.h:38
std::max
T max(T... args)
SourceXtractor::Frame::getDetectionThresholdMap
std::shared_ptr< Image< T > > getDetectionThresholdMap() const
Definition: Frame.cpp:164
ImageAccessor.h
InterpolatedImageSource.h
SourceXtractor::Frame::setBackgroundLevel
void setBackgroundLevel(T background_level)
Definition: Frame.cpp:223
SourceXtractor::LayerThresholdedImage
@ LayerThresholdedImage
Definition: Frame.h:40