LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Types | Public Member Functions | List of all members
lsst::ip::diffim::KernelCandidateDetection< PixelT > Class Template Reference

Search through images for Footprints with no masked pixels. More...

#include <KernelCandidateDetection.h>

Public Types

typedef std::shared_ptr< KernelCandidateDetectionPtr
 
typedef std::shared_ptr< lsst::afw::image::MaskedImage< PixelT > > MaskedImagePtr
 

Public Member Functions

 KernelCandidateDetection (lsst::daf::base::PropertySet const &ps)
 
virtual ~KernelCandidateDetection ()
 
void apply (MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
 Runs Detection on a single image for significant peaks, and checks returned Footprints for Masked pixels. More...
 
bool growCandidate (std::shared_ptr< lsst::afw::detection::Footprint > fp, int fpGrowPix, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
 
std::vector< std::shared_ptr< lsst::afw::detection::Footprint > > getFootprints ()
 

Detailed Description

template<typename PixelT>
class lsst::ip::diffim::KernelCandidateDetection< PixelT >

Search through images for Footprints with no masked pixels.

Note
Runs detection on the template; searches through both images for masked pixels
Parameters
templateMaskedImageMaskedImage that will be convolved with kernel
scienceMaskedImageMaskedImage to subtract convolved template from
psPropertySet for operations; in particular object detection

Definition at line 35 of file KernelCandidateDetection.h.

Member Typedef Documentation

◆ MaskedImagePtr

Definition at line 38 of file KernelCandidateDetection.h.

◆ Ptr

Definition at line 37 of file KernelCandidateDetection.h.

Constructor & Destructor Documentation

◆ KernelCandidateDetection()

Definition at line 35 of file KernelCandidateDetection.cc.

37  :
38  _ps(ps.deepCopy()),
39  _badBitMask(0),
41 
42  std::vector<std::string> detBadMaskPlanes = _ps->getArray<std::string>("badMaskPlanes");
43  for (std::vector<std::string>::iterator mi = detBadMaskPlanes.begin();
44  mi != detBadMaskPlanes.end(); ++mi){
45  try {
47  } catch (pexExcept::Exception& e) {
48  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection",
49  "Cannot update bad bit mask with %s", (*mi).c_str());
50  LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidateDetection",
51  e.what());
52  }
53  }
54  LOGL_DEBUG("TRACE2.ip.diffim.KernelCandidateDetection",
55  "Using bad bit mask %d", _badBitMask);
56  }
#define LOGL_DEBUG(logger, message...)
Log a debug-level message using a varargs/printf style interface.
Definition: Log.h:515
T begin(T... args)
static MaskPixelT getPlaneBitMask(const std::vector< std::string > &names)
Return the bitmask corresponding to a vector of plane names OR'd together.
Definition: Mask.cc:372
Provides consistent interface for LSST exceptions.
Definition: Exception.h:107
virtual char const * what(void) const noexcept
Return a character string summarizing this exception.
Definition: Exception.cc:99
T end(T... args)

◆ ~KernelCandidateDetection()

template<typename PixelT >
virtual lsst::ip::diffim::KernelCandidateDetection< PixelT >::~KernelCandidateDetection ( )
inlinevirtual

Definition at line 42 of file KernelCandidateDetection.h.

42 {};

Member Function Documentation

◆ apply()

template<typename PixelT >
void lsst::ip::diffim::KernelCandidateDetection< PixelT >::apply ( MaskedImagePtr const &  templateMaskedImage,
MaskedImagePtr const &  scienceMaskedImage 
)

Runs Detection on a single image for significant peaks, and checks returned Footprints for Masked pixels.

Note
Accepts two MaskedImages, one of which is to be convolved to match the other. The Detection package is run on either the image to be convolved (assumed to be higher S/N than the other image), or the image to not be convolved (assumed lower S/N; however if you run detection on a very deep template, you might not have significant S/N objects in the science image). The subimages associated with each returned Footprint in both images are checked for Masked pixels; Footprints containing Masked pixels are rejected. The Footprints are grown by an amount specified in the ps. The acceptible Footprints are returned in a vector.
Returns
Vector of "clean" Footprints around which Image Subtraction Kernels will be built.

Definition at line 79 of file KernelCandidateDetection.cc.

82  {
83 
84  // Parse the ps
85  int fpNpixMin = _ps->getAsInt("fpNpixMin");
86  int fpGrowPix = _ps->getAsInt("fpGrowPix");
87 
88  bool detOnTemplate = _ps->getAsBool("detOnTemplate");
89  double detThreshold = _ps->getAsDouble("detThreshold");
90  std::string detThresholdType = _ps->getAsString("detThresholdType");
91 
92  /* reset private variables */
93  _footprints.clear();
94 
95  // List of Footprints
97 
98  // Find detections
99  afwDetect::Threshold threshold =
100  afwDetect::createThreshold(detThreshold, detThresholdType);
101 
102  if (detOnTemplate == true) {
103  afwDetect::FootprintSet footprintSet(
104  *(templateMaskedImage),
105  threshold,
106  "",
107  fpNpixMin);
108  // Get the associated footprints
109 
110  footprintListInPtr = footprintSet.getFootprints();
111  LOGL_DEBUG("TRACE2.ip.diffim.KernelCandidateDetection.apply",
112  "Found %d total footprints in template above %.3f %s",
113  footprintListInPtr->size(), detThreshold, detThresholdType.c_str());
114  }
115  else {
116  afwDetect::FootprintSet footprintSet(
117  *(scienceMaskedImage),
118  threshold,
119  "",
120  fpNpixMin);
121 
122  footprintListInPtr = footprintSet.getFootprints();
123  LOGL_DEBUG("TRACE2.ip.diffim.KernelCandidateDetection.apply",
124  "Found %d total footprints in science image above %.3f %s",
125  footprintListInPtr->size(), detThreshold, detThresholdType.c_str());
126  }
127 
128  // Iterate over footprints, look for "good" ones
129  for (std::vector<std::shared_ptr<afwDetect::Footprint>>::iterator i = footprintListInPtr->begin();
130  i != footprintListInPtr->end(); ++i) {
131 
132  growCandidate((*i), fpGrowPix, templateMaskedImage, scienceMaskedImage);
133  }
134 
135  if (_footprints.size() == 0) {
137  "Unable to find any footprints for Psf matching");
138  }
139 
140  LOGL_DEBUG("TRACE1.ip.diffim.KernelCandidateDetection.apply",
141  "Found %d clean footprints above threshold %.3f",
142  _footprints.size(), detThreshold);
143 
144  }
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
T c_str(T... args)
A set of Footprints, associated with a MaskedImage.
Definition: FootprintSet.h:53
A Threshold is used to pass a threshold value to detection algorithms.
Definition: Threshold.h:43
bool growCandidate(std::shared_ptr< lsst::afw::detection::Footprint > fp, int fpGrowPix, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage)
T clear(T... args)
Threshold createThreshold(const double value, const std::string type="value", const bool polarity=true)
Factory method for creating Threshold objects.
Definition: Threshold.cc:109
T size(T... args)

◆ getFootprints()

Definition at line 52 of file KernelCandidateDetection.h.

52 {return _footprints;};

◆ growCandidate()

template<typename PixelT >
bool lsst::ip::diffim::KernelCandidateDetection< PixelT >::growCandidate ( std::shared_ptr< lsst::afw::detection::Footprint fp,
int  fpGrowPix,
MaskedImagePtr const &  templateMaskedImage,
MaskedImagePtr const &  scienceMaskedImage 
)

Definition at line 147 of file KernelCandidateDetection.cc.

152  {
153  int fpNpixMax = _ps->getAsInt("fpNpixMax");
154 
155  /* Functor to search through the images for masked pixels within *
156  * candidate footprints. Might want to consider changing the default
157  * mask planes it looks through.
158  */
159  FindSetBits<afwImage::Mask<afwImage::MaskPixel> > fsb;
160 
161  geom::Box2I fpBBox = fp->getBBox();
162  /* Failure Condition 1)
163  *
164  * Footprint has too many pixels off the bat. We don't want to throw
165  * away these guys, they have alot of signal! Lets just use the core of
166  * it.
167  *
168  */
169  if (fp->getArea() > static_cast<std::size_t>(fpNpixMax)) {
170  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
171  "Footprint has too many pix: %d (max =%d)",
172  fp->getArea(), fpNpixMax);
173 
174  int xc = int(0.5 * (fpBBox.getMinX() + fpBBox.getMaxX()));
175  int yc = int(0.5 * (fpBBox.getMinY() + fpBBox.getMaxY()));
178  std::make_shared<afwGeom::SpanSet>(geom::Box2I(geom::Point2I(xc, yc),
179  geom::Extent2I(1,1))))
180  );
181  return growCandidate(fpCore, fpGrowPix, templateMaskedImage, scienceMaskedImage);
182  }
183 
184  LOGL_DEBUG("TRACE5.ip.diffim.KernelCandidateDetection.apply",
185  "Original footprint in parent : %d,%d -> %d,%d -> %d,%d",
186  fpBBox.getMinX(), fpBBox.getMinY(),
187  int(0.5 * (fpBBox.getMinX() + fpBBox.getMaxX())),
188  int(0.5 * (fpBBox.getMinY() + fpBBox.getMaxY())),
189  fpBBox.getMaxX(), fpBBox.getMaxY());
190 
191  /* Grow the footprint
192  * flag true = isotropic grow = slow
193  * flag false = 'manhattan grow' = fast
194  *
195  * The manhattan masks are rotated 45 degree w.r.t. the coordinate
196  * system. They intersect the vertices of the rectangle that would
197  * connect pixels (X0,Y0) (X1,Y0), (X0,Y1), (X1,Y1).
198  *
199  * The isotropic masks do take considerably longer to grow and are
200  * basically elliptical. X0, X1, Y0, Y1 delimit the extent of the
201  * ellipse.
202  *
203  * In both cases, since the masks aren't rectangles oriented with
204  * the image coordinate system, when we DO extract such rectangles
205  * as subimages for kernel fitting, some corner pixels can be found
206  * in multiple subimages.
207  *
208  */
209  std::shared_ptr<afwDetect::Footprint> fpGrow = std::make_shared<afwDetect::Footprint>(
210  fp->getSpans()->dilated(fpGrowPix, afwGeom::Stencil::MANHATTAN)
211  );
212 
213  /* Next we look at the image within this Footprint.
214  */
215  geom::Box2I fpGrowBBox = fpGrow->getBBox();
216  LOGL_DEBUG("TRACE5.ip.diffim.KernelCandidateDetection.apply",
217  "Grown footprint in parent : %d,%d -> %d,%d -> %d,%d",
218  fpGrowBBox.getMinX(), fpGrowBBox.getMinY(),
219  int(0.5 * (fpGrowBBox.getMinX() + fpGrowBBox.getMaxX())),
220  int(0.5 * (fpGrowBBox.getMinY() + fpGrowBBox.getMaxY())),
221  fpGrowBBox.getMaxX(), fpGrowBBox.getMaxY());
222 
223  /* Failure Condition 2)
224  * Grown off the image
225  */
226  if (!(templateMaskedImage->getBBox().contains(fpGrowBBox))) {
227  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
228  "Footprint grown off image");
229  return false;
230  }
231 
232  /* Grab subimages; report any exception */
233  bool subimageHasFailed = false;
234  try {
235  afwImage::MaskedImage<PixelT> templateSubimage(*templateMaskedImage, fpGrowBBox);
236  afwImage::MaskedImage<PixelT> scienceSubimage(*scienceMaskedImage, fpGrowBBox);
237 
238  // Search for any masked pixels within the footprint
239  fsb.apply(*(templateSubimage.getMask()));
240  if (fsb.getBits() & _badBitMask) {
241  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
242  "Footprint has masked pix (vals=%d) in image to convolve",
243  fsb.getBits());
244  subimageHasFailed = true;
245  }
246 
247  fsb.apply(*(scienceSubimage.getMask()));
248  if (fsb.getBits() & _badBitMask) {
249  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
250  "Footprint has masked pix (vals=%d) in image not to convolve",
251  fsb.getBits());
252  subimageHasFailed = true;
253  }
254 
255  } catch (pexExcept::Exception& e) {
256  LOGL_DEBUG("TRACE3.ip.diffim.KernelCandidateDetection.apply",
257  "Exception caught extracting Footprint");
258  LOGL_DEBUG("TRACE4.ip.diffim.KernelCandidateDetection.apply",
259  e.what());
260  subimageHasFailed = true;
261  }
262  if (subimageHasFailed) {
263  return false;
264  } else {
265  /* We have a good candidate */
266  _footprints.push_back(fpGrow);
267  return true;
268  }
269  }
Class to describe the properties of a detected object from an image.
Definition: Footprint.h:63
std::shared_ptr< geom::SpanSet > getSpans() const
Return a shared pointer to the SpanSet.
Definition: Footprint.h:115
lsst::geom::Box2I getBBox() const
Return the Footprint's bounding box.
Definition: Footprint.h:208
std::size_t getArea() const
Return the number of pixels in this Footprint.
Definition: Footprint.h:173
A class to manipulate images, masks, and variance as a single object.
Definition: MaskedImage.h:73
An integer coordinate rectangle.
Definition: Box.h:55
int getMinY() const noexcept
Definition: Box.h:158
int getMinX() const noexcept
Definition: Box.h:157
int getMaxX() const noexcept
Definition: Box.h:161
int getMaxY() const noexcept
Definition: Box.h:162
T push_back(T... args)

The documentation for this class was generated from the following files: