lsst.meas.base  16.0-8-g2ce35ff+3
PeakLikelihoodFlux.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 /*
3  * LSST Data Management System
4  * Copyright 2008-2013 LSST Corporation.
5  *
6  * This product includes software developed by the
7  * LSST Project (http://www.lsst.org/).
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the LSST License Statement and
20  * the GNU General Public License along with this program. If not,
21  * see <http://www.lsstcorp.org/LegalNotices/>.
22  */
23 
24 #include "ndarray/eigen.h"
25 
26 #include "lsst/afw/detection/Psf.h"
27 #include "lsst/geom/Box.h"
28 #include "lsst/pex/exceptions.h"
29 #include "lsst/afw/geom.h"
30 #include "lsst/afw/image.h"
31 #include "lsst/afw/math.h"
32 
34 #include "lsst/afw/table/Source.h"
35 
36 namespace lsst {
37 namespace meas {
38 namespace base {
39 namespace {
40 FlagDefinitionList flagDefinitions;
41 } // namespace
42 
43 FlagDefinition const PeakLikelihoodFluxAlgorithm::FAILURE = flagDefinitions.addFailureFlag();
44 
46 
47 namespace {
48 
49 /************************************************************************************************************/
66 class PsfAttributes {
67 public:
68  enum Method {
69  ADAPTIVE_MOMENT,
70  FIRST_MOMENT,
71  SECOND_MOMENT,
72  NOISE_EQUIVALENT,
73  BICKERTON
74  };
75 
76  PsfAttributes(CONST_PTR(afw::detection::Psf) psf, int const iX, int const iY);
77  PsfAttributes(CONST_PTR(afw::detection::Psf) psf, geom::Point2I const &cen);
78 
79  double computeGaussianWidth(Method how = ADAPTIVE_MOMENT) const;
80  double computeEffectiveArea() const;
81 
82 private:
83  PTR(afw::image::Image<double>) _psfImage;
84 };
85 
89 PsfAttributes::PsfAttributes(CONST_PTR(afw::detection::Psf) psf,
90  int const iX,
91  int const iY
92 ) {
93  // N.b. (iX, iY) are ints so that we know this image is centered in the central pixel of _psfImage
94  _psfImage = psf->computeImage(geom::PointD(iX, iY));
95 }
96 
100 PsfAttributes::PsfAttributes(
102  geom::Point2I const &cen
103  )
104  : // N.b. cen is a PointI so that we know this image is centered in the central pixel of _psfImage
105  _psfImage(psf->computeImage(geom::PointD(cen))) {}
106 
111 double PsfAttributes::computeEffectiveArea() const {
112  double sum = 0.0;
113  double sumsqr = 0.0;
114  for (int iY = 0; iY != _psfImage->getHeight(); ++iY) {
115  afw::image::Image<double>::x_iterator end = _psfImage->row_end(iY);
116  for (afw::image::Image<double>::x_iterator ptr = _psfImage->row_begin(iY); ptr != end; ++ptr) {
117  sum += *ptr;
118  sumsqr += (*ptr) * (*ptr);
119  }
120  }
121  return sum * sum / sumsqr;
122 }
123 
124 } // end anonymous namespace
125 
133 template <typename T>
135  afw::image::MaskedImage<T> const &maskedImage,
136  std::string const &warpingKernelName,
137  geom::Point2D const &fracShift,
138  geom::Point2I const &parentInd
139 ) {
140  typedef typename afw::image::Exposure<T>::MaskedImageT MaskedImageT;
141  typedef typename afw::image::Image<double> KernelImageT;
142 
143  PTR(afw::math::SeparableKernel) warpingKernelPtr = afw::math::makeWarpingKernel(warpingKernelName);
144 
145  if ((std::abs(fracShift[0]) >= 1) || (std::abs(fracShift[1]) >= 1)) {
147  os << "fracShift = " << fracShift << " too large; abs value must be < 1 in both axes";
149  }
150 
151  // warping kernels have even dimension and want the peak to the right of center
152  if (fracShift[0] < 0) {
153  warpingKernelPtr->setCtrX(warpingKernelPtr->getCtrX() + 1);
154  }
155  if (fracShift[1] < 0) {
156  warpingKernelPtr->setCtrY(warpingKernelPtr->getCtrY() + 1);
157  }
158  geom::Box2I warpingOverlapBBox(parentInd - geom::Extent2I(warpingKernelPtr->getCtr()),
159  warpingKernelPtr->getDimensions());
160  if (!maskedImage.getBBox().contains(warpingOverlapBBox)) {
162  os << "Warping kernel extends off the edge"
163  << "; kernel bbox = " << warpingOverlapBBox << "; exposure bbox = " << maskedImage.getBBox();
165  }
166  warpingKernelPtr->setKernelParameters(std::make_pair(fracShift[0], fracShift[1]));
167  KernelImageT warpingKernelImage(warpingKernelPtr->getDimensions());
168  warpingKernelPtr->computeImage(warpingKernelImage, true);
169  typename KernelImageT::const_xy_locator const warpingKernelLoc = warpingKernelImage.xy_at(0, 0);
170 
171  // Compute imLoc: an image locator that matches kernel locator (0,0) such that
172  // image ctrPix overlaps center of warping kernel
173  geom::Point2I subimMin = warpingOverlapBBox.getMin();
174  typename MaskedImageT::const_xy_locator const mimageLoc =
175  maskedImage.xy_at(subimMin.getX(), subimMin.getY());
176  return afw::math::convolveAtAPoint<MaskedImageT, MaskedImageT>(
177  mimageLoc, warpingKernelLoc, warpingKernelPtr->getWidth(), warpingKernelPtr->getHeight());
178 }
180  afw::table::Schema &schema)
181  : _ctrl(ctrl),
182  _fluxResultKey(FluxResultKey::addFields(schema, name, "flux from PeakLikelihood Flux algorithm")),
183  _centroidExtractor(schema, name) {
184  _flagHandler = FlagHandler::addFields(schema, name, getFlagDefinitions());
185 }
186 
188  afw::image::Exposure<float> const &exposure) const {
189  // get the value from the centroid slot only
190  geom::Point2D center = _centroidExtractor(measRecord, _flagHandler);
192  typedef afw::image::Exposure<float>::MaskedImageT MaskedImageT;
193  MaskedImageT const &mimage = exposure.getMaskedImage();
194 
205  if (!exposure.hasPsf()) {
206  throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "exposure has no PSF");
207  }
208  PTR(afw::detection::Psf const) psfPtr = exposure.getPsf();
209  if (!geom::Box2D(mimage.getBBox()).contains(center)) {
211  os << "Center = " << center << " not in exposure bbox" << mimage.getBBox();
213  }
214 
215  // compute parent index and fractional offset of ctrPix: the pixel closest to "center",
216  // the centroid of the source
217  std::pair<int, double> const xCtrPixParentIndFrac = afw::image::positionToIndex(center.getX(), true);
218  std::pair<int, double> const yCtrPixParentIndFrac = afw::image::positionToIndex(center.getY(), true);
219 
220  geom::Point2I ctrPixParentInd(xCtrPixParentIndFrac.first, yCtrPixParentIndFrac.first);
221  geom::Point2D ctrPixPos(afw::image::indexToPosition(ctrPixParentInd[0]),
222  afw::image::indexToPosition(ctrPixParentInd[1]));
223 
224  // compute weight = 1/sum(PSF^2) for PSF at ctrPix, where PSF is normalized to a sum of 1
225  PsfAttributes psfAttr(psfPtr, ctrPixParentInd);
226  double weight = psfAttr.computeEffectiveArea();
227 
228  /*
229  * Compute value of image at center of source, as shifted by a fractional pixel to center the source
230  * on ctrPix.
231  */
232  MaskedImageT::SinglePixel mimageCtrPix = computeShiftedValue(
233  mimage, _ctrl.warpingKernelName,
234  geom::Point2D(xCtrPixParentIndFrac.second, yCtrPixParentIndFrac.second), ctrPixParentInd);
235  double flux = mimageCtrPix.image() * weight;
236  double var = mimageCtrPix.variance() * weight * weight;
237  result.flux = flux;
238  result.fluxSigma = std::sqrt(var);
239  measRecord.set(_fluxResultKey, result);
240  _flagHandler.setValue(measRecord, FAILURE.number, false);
241 }
242 
244  _flagHandler.handleFailure(measRecord, error);
245 }
246 
247 } // namespace base
248 } // namespace meas
249 } // namespace lsst
double indexToPosition(double ind)
int positionToIndex(double pos)
_view_t::x_iterator x_iterator
PeakLikelihoodFluxAlgorithm(Control const &ctrl, std::string const &name, afw::table::Schema &schema)
afw::image::MaskedImage< T >::SinglePixel computeShiftedValue(afw::image::MaskedImage< T > const &maskedImage, std::string const &warpingKernelName, geom::Point2D const &fracShift, geom::Point2I const &parentInd)
Compute the value of one pixel of an image after a fractional pixel shift Since we only want the valu...
#define PTR(...)
Key< int > psf
void setValue(afw::table::BaseRecord &record, std::size_t i, bool value) const
Set the flag field corresponding to the given flag index.
Definition: FlagHandler.h:262
Exception to be thrown when a measurement algorithm experiences a known failure mode.
Definition: exceptions.h:48
std::shared_ptr< Image > computeImage(lsst::geom::Point2D position=makeNullPoint(), image::Color color=image::Color(), ImageOwnerEnum owner=COPY) const
#define CONST_PTR(...)
C++ control object for peak likelihood flux.
std::shared_ptr< SeparableKernel > makeWarpingKernel(std::string name)
STL class.
virtual void fail(afw::table::SourceRecord &measRecord, MeasurementError *error=nullptr) const
Handle an exception thrown by the current algorithm by setting flags in the given record...
MaskedImageT getMaskedImage()
int end
virtual void measure(afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure) const
Called to measure a single child source in an image.
T str(T... args)
T make_pair(T... args)
Flux flux
Measured flux in DN.
Definition: FluxUtilities.h:42
A FunctorKey for FluxResult.
Definition: FluxUtilities.h:58
std::unique_ptr< SchemaItem< U > > result
static FlagHandler addFields(afw::table::Schema &schema, std::string const &prefix, FlagDefinitionList const &flagDefs, FlagDefinitionList const &exclDefs=FlagDefinitionList::getEmptyList())
Add Flag fields to a schema, creating a FlagHandler object to manage them.
Definition: FlagHandler.cc:37
#define LSST_EXCEPT(type,...)
std::string warpingKernelName
"Name of warping kernel (e.g. \"lanczos4") used to compute the peak" ;
std::shared_ptr< lsst::afw::detection::Psf > getPsf()
bool contains(Point2I const &point) const noexcept
void handleFailure(afw::table::BaseRecord &record, MeasurementError const *error=nullptr) const
Handle an expected or unexpected Exception thrown by a measurement algorithm.
Definition: FlagHandler.cc:76
void set(Key< T > const &key, U const &value)
T sqrt(T... args)
vector-type utility class to build a collection of FlagDefinitions
Definition: FlagHandler.h:60
FluxErrElement fluxSigma
1-Sigma error (sqrt of variance) on flux in DN.
Definition: FluxUtilities.h:43
lsst::geom::Box2I getBBox(ImageOrigin const origin=PARENT) const
std::ostream * os
A reusable result struct for flux measurements.
Definition: FluxUtilities.h:41
xy_locator xy_at(int x, int y) const
static FlagDefinitionList const & getFlagDefinitions()