lsst.meas.base  13.0-33-gb1a1d47
plugins.py
Go to the documentation of this file.
1 #!/usr/bin/env python
2 #
3 # LSST Data Management System
4 # Copyright 2008-2016 AURA/LSST.
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 Definitions and registration of pure-Python plugins with trivial implementations,
25 and automatic plugin-from-algorithm calls for those implemented in C++.
26 """
27 import numpy
28 
29 import lsst.pex.exceptions
30 import lsst.afw.detection
31 import lsst.afw.geom
32 
33 from .pluginRegistry import register
34 from .pluginsBase import BasePlugin
35 from .sfm import SingleFramePluginConfig, SingleFramePlugin
36 from .forcedMeasurement import ForcedPluginConfig, ForcedPlugin
37 from .wrappers import wrapSimpleAlgorithm, wrapTransform
38 from .transforms import SimpleCentroidTransform
39 
40 from .apertureFlux import ApertureFluxControl, ApertureFluxTransform
41 from .transform import BaseTransform
42 from .blendedness import BlendednessAlgorithm, BlendednessControl
43 from .circularApertureFlux import CircularApertureFluxAlgorithm
44 from .gaussianCentroid import GaussianCentroidAlgorithm, GaussianCentroidControl, GaussianCentroidTransform
45 from .gaussianFlux import GaussianFluxAlgorithm, GaussianFluxControl, GaussianFluxTransform
46 from .exceptions import MeasurementError
47 from .naiveCentroid import NaiveCentroidAlgorithm, NaiveCentroidControl, NaiveCentroidTransform
48 from .peakLikelihoodFlux import PeakLikelihoodFluxAlgorithm, PeakLikelihoodFluxControl, \
49  PeakLikelihoodFluxTransform
50 from .pixelFlags import PixelFlagsAlgorithm, PixelFlagsControl
51 from .psfFlux import PsfFluxAlgorithm, PsfFluxControl, PsfFluxTransform
52 from .scaledApertureFlux import ScaledApertureFluxAlgorithm, ScaledApertureFluxControl, \
53  ScaledApertureFluxTransform
54 from .sdssCentroid import SdssCentroidAlgorithm, SdssCentroidControl, SdssCentroidTransform
55 from .sdssShape import SdssShapeAlgorithm, SdssShapeControl, SdssShapeTransform
56 
57 __all__ = (
58  "SingleFrameFPPositionConfig", "SingleFrameFPPositionPlugin",
59  "SingleFrameJacobianConfig", "SingleFrameJacobianPlugin",
60  "SingleFrameVarianceConfig", "SingleFrameVariancePlugin",
61  "SingleFrameInputCountConfig", "SingleFrameInputCountPlugin",
62  "SingleFramePeakCentroidConfig", "SingleFramePeakCentroidPlugin",
63  "SingleFrameSkyCoordConfig", "SingleFrameSkyCoordPlugin",
64  "ForcedPeakCentroidConfig", "ForcedPeakCentroidPlugin",
65  "ForcedTransformedCentroidConfig", "ForcedTransformedCentroidPlugin",
66  "ForcedTransformedShapeConfig", "ForcedTransformedShapePlugin",
67 )
68 
69 # --- Wrapped C++ Plugins ---
70 
71 wrapSimpleAlgorithm(PsfFluxAlgorithm, Control=PsfFluxControl,
72  TransformClass=PsfFluxTransform, executionOrder=BasePlugin.FLUX_ORDER,
73  shouldApCorr=True, hasLogName=True)
74 wrapSimpleAlgorithm(PeakLikelihoodFluxAlgorithm, Control=PeakLikelihoodFluxControl,
75  TransformClass=PeakLikelihoodFluxTransform, executionOrder=BasePlugin.FLUX_ORDER)
76 wrapSimpleAlgorithm(GaussianFluxAlgorithm, Control=GaussianFluxControl,
77  TransformClass=GaussianFluxTransform, executionOrder=BasePlugin.FLUX_ORDER,
78  shouldApCorr=True)
79 wrapSimpleAlgorithm(GaussianCentroidAlgorithm, Control=GaussianCentroidControl,
80  TransformClass=GaussianCentroidTransform, executionOrder=BasePlugin.CENTROID_ORDER)
81 wrapSimpleAlgorithm(NaiveCentroidAlgorithm, Control=NaiveCentroidControl,
82  TransformClass=NaiveCentroidTransform, executionOrder=BasePlugin.CENTROID_ORDER)
83 wrapSimpleAlgorithm(SdssCentroidAlgorithm, Control=SdssCentroidControl,
84  TransformClass=SdssCentroidTransform, executionOrder=BasePlugin.CENTROID_ORDER)
85 wrapSimpleAlgorithm(PixelFlagsAlgorithm, Control=PixelFlagsControl,
86  executionOrder=BasePlugin.FLUX_ORDER)
87 wrapSimpleAlgorithm(SdssShapeAlgorithm, Control=SdssShapeControl,
88  TransformClass=SdssShapeTransform, executionOrder=BasePlugin.SHAPE_ORDER)
89 wrapSimpleAlgorithm(ScaledApertureFluxAlgorithm, Control=ScaledApertureFluxControl,
90  TransformClass=ScaledApertureFluxTransform, executionOrder=BasePlugin.FLUX_ORDER)
91 
92 wrapSimpleAlgorithm(CircularApertureFluxAlgorithm, needsMetadata=True, Control=ApertureFluxControl,
93  TransformClass=ApertureFluxTransform, executionOrder=BasePlugin.FLUX_ORDER)
94 wrapSimpleAlgorithm(BlendednessAlgorithm, Control=BlendednessControl,
95  TransformClass=BaseTransform, executionOrder=BasePlugin.SHAPE_ORDER)
96 
97 wrapTransform(PsfFluxTransform)
98 wrapTransform(PeakLikelihoodFluxTransform)
99 wrapTransform(GaussianFluxTransform)
100 wrapTransform(GaussianCentroidTransform)
101 wrapTransform(NaiveCentroidTransform)
102 wrapTransform(SdssCentroidTransform)
103 wrapTransform(SdssShapeTransform)
104 wrapTransform(ScaledApertureFluxTransform)
105 wrapTransform(ApertureFluxTransform)
106 
107 # --- Single-Frame Measurement Plugins ---
108 
109 
111  pass
112 
113 
114 @register("base_FPPosition")
116  '''
117  Algorithm to calculate the position of a centroid on the focal plane
118  '''
119 
120  ConfigClass = SingleFrameFPPositionConfig
121 
122  @classmethod
124  return cls.SHAPE_ORDER
125 
126  def __init__(self, config, name, schema, metadata):
127  SingleFramePlugin.__init__(self, config, name, schema, metadata)
128  self.focalValue = lsst.afw.table.Point2DKey.addFields(schema, name, "Position on the focal plane",
129  "mm")
130  self.focalFlag = schema.addField(name + "_flag", type="Flag", doc="Set to True for any fatal failure")
131  self.detectorFlag = schema.addField(name + "_missingDetector_flag", type="Flag",
132  doc="Set to True if detector object is missing")
133 
134  def measure(self, measRecord, exposure):
135  det = exposure.getDetector()
136  if not det:
137  measRecord.set(self.detectorFlag, True)
138  fp = lsst.afw.geom.Point2D(numpy.nan, numpy.nan)
139  else:
140  center = measRecord.getCentroid()
141  posInPix = det.makeCameraPoint(center, lsst.afw.cameraGeom.PIXELS)
142  fp = det.transform(posInPix, lsst.afw.cameraGeom.FOCAL_PLANE).getPoint()
143  measRecord.set(self.focalValue, fp)
144 
145  def fail(self, measRecord, error=None):
146  measRecord.set(self.focalFlag, True)
147 
148 
150  pixelScale = lsst.pex.config.Field(dtype=float, default=0.5, doc="Nominal pixel size (arcsec)")
151 
152 
153 @register("base_Jacobian")
155  '''
156  Algorithm which computes the Jacobian about a source and computes its ratio with a nominal pixel area.
157  This allows one to compare relative instead of absolute areas of pixels.
158  '''
159 
160  ConfigClass = SingleFrameJacobianConfig
161 
162  @classmethod
164  return cls.SHAPE_ORDER
165 
166  def __init__(self, config, name, schema, metadata):
167  SingleFramePlugin.__init__(self, config, name, schema, metadata)
168  self.jacValue = schema.addField(name + '_value', type="D", doc="Jacobian correction")
169  self.jacFlag = schema.addField(name + '_flag', type="Flag", doc="Set to 1 for any fatal failure")
170  # Calculate one over the area of a nominal reference pixel
171  self.scale = pow(self.config.pixelScale, -2)
172 
173  def measure(self, measRecord, exposure):
174  center = measRecord.getCentroid()
175  # Compute the area of a pixel at the center of a source records centroid, and take the
176  # ratio of that with the defined reference pixel area.
177  result = numpy.abs(self.scale*exposure.getWcs().linearizePixelToSky(
178  center,
179  lsst.afw.geom.arcseconds).getLinear().computeDeterminant())
180  measRecord.set(self.jacValue, result)
181 
182  def fail(self, measRecord, error=None):
183  measRecord.set(self.jacFlag, True)
184 
185 
187  scale = lsst.pex.config.Field(dtype=float, default=5.0, optional=True,
188  doc="Scale factor to apply to shape for aperture")
189  mask = lsst.pex.config.ListField(doc="Mask planes to ignore", dtype=str,
190  default=["DETECTED", "DETECTED_NEGATIVE", "BAD", "SAT"])
191 
192 
193 @register("base_Variance")
195  '''
196  Calculate the median variance within a Footprint scaled from the object shape so
197  the value is not terribly influenced by the object and instead represents the
198  variance in the background near the object.
199  '''
200  ConfigClass = SingleFrameVarianceConfig
201  FAILURE_BAD_CENTROID = 1
202  FAILURE_EMPTY_FOOTPRINT = 2
203 
204  @classmethod
206  return cls.FLUX_ORDER
207 
208  def __init__(self, config, name, schema, metadata):
209  SingleFramePlugin.__init__(self, config, name, schema, metadata)
210  self.varValue = schema.addField(name + '_value', type="D", doc="Variance at object position")
211  self.varFlag = schema.addField(name + '_flag', type="Flag", doc="Set to True for any fatal failure")
212  self.emptyFootprintFlag = schema.addField(name + '_flag_emptyFootprint', type="Flag",
213  doc="Set to True when the footprint has no usable pixels")
214 
215  # Alias the badCentroid flag to that which is defined for the target of the centroid slot.
216  # We do not simply rely on the alias because that could be changed post-measurement.
217  schema.getAliasMap().set(name + '_flag_badCentroid', schema.getAliasMap().apply("slot_Centroid_flag"))
218 
219  def measure(self, measRecord, exposure):
220  if measRecord.getCentroidFlag():
221  raise MeasurementError("Source record has a bad centroid.", self.FAILURE_BAD_CENTROID)
222  # Create an aperture and grow it by scale value defined in config to ensure there are enough
223  # pixels around the object to get decent statistics
224  aperture = lsst.afw.geom.ellipses.Ellipse(measRecord.getShape(), measRecord.getCentroid())
225  aperture.scale(self.config.scale)
226  ellipse = lsst.afw.geom.SpanSet.fromShape(aperture)
227  foot = lsst.afw.detection.Footprint(ellipse)
228  foot.clipTo(exposure.getBBox(lsst.afw.image.PARENT))
229  # Filter out any pixels which have mask bits set corresponding to the planes to be excluded
230  # (defined in config.mask)
231  maskedImage = exposure.getMaskedImage()
232  pixels = lsst.afw.detection.makeHeavyFootprint(foot, maskedImage)
233  maskBits = maskedImage.getMask().getPlaneBitMask(self.config.mask)
234  logicalMask = numpy.logical_not(pixels.getMaskArray() & maskBits)
235  # Compute the median variance value for each pixel not excluded by the mask and write the record.
236  # Numpy median is used here instead of afw.math makeStatistics because of an issue with data types
237  # being passed into the C++ layer (DM-2379).
238  if numpy.any(logicalMask):
239  medVar = numpy.median(pixels.getVarianceArray()[logicalMask])
240  measRecord.set(self.varValue, medVar)
241  else:
242  raise MeasurementError("Footprint empty, or all pixels are masked, can't compute median",
244 
245  def fail(self, measRecord, error=None):
246  # Check that we have a error object and that it is of type MeasurementError
247  if isinstance(error, MeasurementError):
248  assert error.getFlagBit() in (self.FAILURE_BAD_CENTROID, self.FAILURE_EMPTY_FOOTPRINT)
249  # FAILURE_BAD_CENTROID handled by alias to centroid record.
250  if error.getFlagBit() == self.FAILURE_EMPTY_FOOTPRINT:
251  measRecord.set(self.emptyFootprintFlag, True)
252  measRecord.set(self.varValue, numpy.nan)
253  measRecord.set(self.varFlag, True)
254 
255 
257  pass
258 
259 
260 @register("base_InputCount")
262  """
263  Plugin to count how many input images contributed to each source. This information
264  is in the exposure's coaddInputs. Some limitations:
265  * This is only for the pixel containing the center, not for all the pixels in the
266  Footprint
267  * This does not account for any clipping in the coadd
268  """
269 
270  ConfigClass = SingleFrameInputCountConfig
271  FAILURE_BAD_CENTROID = 1
272  FAILURE_NO_INPUTS = 2
273 
274  @classmethod
276  return cls.SHAPE_ORDER
277 
278  def __init__(self, config, name, schema, metadata):
279  SingleFramePlugin.__init__(self, config, name, schema, metadata)
280  self.numberKey = schema.addField(name + '_value', type="I",
281  doc="Number of images contributing at center, not including any"
282  "clipping")
283  self.numberFlag = schema.addField(name + '_flag', type="Flag", doc="Set to True for fatal failure")
284  self.noInputsFlag = schema.addField(name + '_flag_noInputs', type="Flag",
285  doc="No coadd inputs available")
286  # Alias the badCentroid flag to that which is defined for the target of the centroid slot.
287  # We do not simply rely on the alias because that could be changed post-measurement.
288  schema.getAliasMap().set(name + '_flag_badCentroid', schema.getAliasMap().apply("slot_Centroid_flag"))
289 
290  def measure(self, measRecord, exposure):
291  if not exposure.getInfo().getCoaddInputs():
292  raise MeasurementError("No coadd inputs defined.", self.FAILURE_NO_INPUTS)
293  if measRecord.getCentroidFlag():
294  raise MeasurementError("Source has a bad centroid.", self.FAILURE_BAD_CENTROID)
295 
296  center = measRecord.getCentroid()
297  ccds = exposure.getInfo().getCoaddInputs().ccds
298  measRecord.set(self.numberKey, len(ccds.subsetContaining(center, exposure.getWcs())))
299 
300  def fail(self, measRecord, error=None):
301  measRecord.set(self.numberFlag, True)
302  if error is not None:
303  assert error.getFlagBit() in (self.FAILURE_BAD_CENTROID, self.FAILURE_NO_INPUTS)
304  # FAILURE_BAD_CENTROID handled by alias to centroid record.
305  if error.getFlagBit() == self.FAILURE_NO_INPUTS:
306  measRecord.set(self.noInputsFlag, True)
307 
308 
310  pass
311 
312 
313 @register("base_PeakCentroid")
315  """
316  A centroid algorithm that simply uses the first (i.e. highest) Peak in the Source's
317  Footprint as the centroid. This is of course a relatively poor measure of the true
318  centroid of the object; this algorithm is provided mostly for testing and debugging.
319  """
320 
321  ConfigClass = SingleFramePeakCentroidConfig
322 
323  @classmethod
325  return cls.CENTROID_ORDER
326 
327  def __init__(self, config, name, schema, metadata):
328  SingleFramePlugin.__init__(self, config, name, schema, metadata)
329  self.keyX = schema.addField(name + "_x", type="D", doc="peak centroid", units="pixel")
330  self.keyY = schema.addField(name + "_y", type="D", doc="peak centroid", units="pixel")
331  self.flag = schema.addField(name + "_flag", type="Flag", doc="Centroiding failed")
332 
333  def measure(self, measRecord, exposure):
334  peak = measRecord.getFootprint().getPeaks()[0]
335  measRecord.set(self.keyX, peak.getFx())
336  measRecord.set(self.keyY, peak.getFy())
337 
338  def fail(self, measRecord, error=None):
339  measRecord.set(self.flag, True)
340 
341  @staticmethod
343  return SimpleCentroidTransform
344 
345 
347  pass
348 
349 
350 @register("base_SkyCoord")
352  """
353  A measurement plugin that sets the "coord" field (part of the Source minimal schema)
354  using the slot centroid and the Wcs attached to the Exposure.
355  """
356 
357  ConfigClass = SingleFrameSkyCoordConfig
358 
359  @classmethod
361  return cls.SHAPE_ORDER
362 
363  def measure(self, measRecord, exposure):
364  # there should be a base class method for handling this exception. Put this on a later ticket
365  # Also, there should be a python Exception of the appropriate type for this error
366  if not exposure.hasWcs():
367  raise Exception("Wcs not attached to exposure. Required for " + self.name + " algorithm")
368  measRecord.updateCoord(exposure.getWcs())
369 
370  def fail(self, measRecord, error=None):
371  # Override fail() to do nothing in the case of an exception: this is not ideal,
372  # but we don't have a place to put failures because we don't allocate any fields.
373  # Should consider fixing as part of DM-1011
374  pass
375 
376 
377 # --- Forced Plugins ---
378 
379 class ForcedPeakCentroidConfig(ForcedPluginConfig):
380  pass
381 
382 
383 @register("base_PeakCentroid")
385  """
386  The forced peak centroid is like the SFM peak centroid plugin, except that it must transform
387  the peak coordinate from the original (reference) coordinate system to the coordinate system
388  of the exposure being measured.
389  """
390 
391  ConfigClass = ForcedPeakCentroidConfig
392 
393  @classmethod
395  return cls.CENTROID_ORDER
396 
397  def __init__(self, config, name, schemaMapper, metadata):
398  ForcedPlugin.__init__(self, config, name, schemaMapper, metadata)
399  schema = schemaMapper.editOutputSchema()
400  self.keyX = schema.addField(name + "_x", type="D", doc="peak centroid", units="pixel")
401  self.keyY = schema.addField(name + "_y", type="D", doc="peak centroid", units="pixel")
402 
403  def measure(self, measRecord, exposure, refRecord, refWcs):
404  targetWcs = exposure.getWcs()
405  peak = refRecord.getFootprint().getPeaks()[0]
406  result = lsst.afw.geom.Point2D(peak.getFx(), peak.getFy())
407  if not refWcs == targetWcs:
408  result = targetWcs.skyToPixel(refWcs.pixelToSky(result))
409  measRecord.set(self.keyX, result.getX())
410  measRecord.set(self.keyY, result.getY())
411 
412  @staticmethod
414  return SimpleCentroidTransform
415 
416 
418  pass
419 
420 
421 @register("base_TransformedCentroid")
423  """A centroid pseudo-algorithm for forced measurement that simply transforms the centroid
424  from the reference catalog to the measurement coordinate system. This is used as
425  the slot centroid by default in forced measurement, allowing subsequent measurements
426  to simply refer to the slot value just as they would in single-frame measurement.
427  """
428 
429  ConfigClass = ForcedTransformedCentroidConfig
430 
431  @classmethod
433  return cls.CENTROID_ORDER
434 
435  def __init__(self, config, name, schemaMapper, metadata):
436  ForcedPlugin.__init__(self, config, name, schemaMapper, metadata)
437  schema = schemaMapper.editOutputSchema()
438  # Allocate x and y fields, join these into a single FunctorKey for ease-of-use.
439  xKey = schema.addField(name + "_x", type="D", doc="transformed reference centroid column",
440  units="pixel")
441  yKey = schema.addField(name + "_y", type="D", doc="transformed reference centroid row",
442  units="pixel")
443  self.centroidKey = lsst.afw.table.Point2DKey(xKey, yKey)
444  # Because we're taking the reference position as given, we don't bother transforming its
445  # uncertainty and reporting that here, so there are no sigma or cov fields. We do propagate
446  # the flag field, if it exists.
447  if "slot_Centroid_flag" in schemaMapper.getInputSchema():
448  self.flagKey = schema.addField(name + "_flag", type="Flag",
449  doc="whether the reference centroid is marked as bad")
450  else:
451  self.flagKey = None
452 
453  def measure(self, measRecord, exposure, refRecord, refWcs):
454  targetWcs = exposure.getWcs()
455  if not refWcs == targetWcs:
456  targetPos = targetWcs.skyToPixel(refWcs.pixelToSky(refRecord.getCentroid()))
457  measRecord.set(self.centroidKey, targetPos)
458  else:
459  measRecord.set(self.centroidKey, refRecord.getCentroid())
460  if self.flagKey is not None:
461  measRecord.set(self.flagKey, refRecord.getCentroidFlag())
462 
463 
465  pass
466 
467 
468 @register("base_TransformedShape")
470  """A shape pseudo-algorithm for forced measurement that simply transforms the shape
471  from the reference catalog to the measurement coordinate system. This is used as
472  the slot shape by default in forced measurement, allowing subsequent measurements
473  to simply refer to the slot value just as they would in single-frame measurement.
474  """
475 
476  ConfigClass = ForcedTransformedShapeConfig
477 
478  @classmethod
480  return cls.SHAPE_ORDER
481 
482  def __init__(self, config, name, schemaMapper, metadata):
483  ForcedPlugin.__init__(self, config, name, schemaMapper, metadata)
484  schema = schemaMapper.editOutputSchema()
485  # Allocate xx, yy, xy fields, join these into a single FunctorKey for ease-of-use.
486  xxKey = schema.addField(name + "_xx", type="D", doc="transformed reference shape x^2 moment",
487  units="pixel^2")
488  yyKey = schema.addField(name + "_yy", type="D", doc="transformed reference shape y^2 moment",
489  units="pixel^2")
490  xyKey = schema.addField(name + "_xy", type="D", doc="transformed reference shape xy moment",
491  units="pixel^2")
492  self.shapeKey = lsst.afw.table.QuadrupoleKey(xxKey, yyKey, xyKey)
493  # Because we're taking the reference position as given, we don't bother transforming its
494  # uncertainty and reporting that here, so there are no sigma or cov fields. We do propagate
495  # the flag field, if it exists.
496  if "slot_Shape_flag" in schemaMapper.getInputSchema():
497  self.flagKey = schema.addField(name + "_flag", type="Flag",
498  doc="whether the reference shape is marked as bad")
499  else:
500  self.flagKey = None
501 
502  def measure(self, measRecord, exposure, refRecord, refWcs):
503  targetWcs = exposure.getWcs()
504  if not refWcs == targetWcs:
505  fullTransform = lsst.afw.image.XYTransformFromWcsPair(targetWcs, refWcs)
506  localTransform = fullTransform.linearizeForwardTransform(refRecord.getCentroid())
507  measRecord.set(self.shapeKey, refRecord.getShape().transform(localTransform.getLinear()))
508  else:
509  measRecord.set(self.shapeKey, refRecord.getShape())
510  if self.flagKey is not None:
511  measRecord.set(self.flagKey, refRecord.getShapeFlag())
def measure(self, measRecord, exposure)
Definition: plugins.py:333
def fail(self, measRecord, error=None)
Definition: plugins.py:370
def __init__(self, config, name, schema, metadata)
Definition: plugins.py:126
def fail(self, measRecord, error=None)
Definition: plugins.py:338
def fail(self, measRecord, error=None)
Definition: plugins.py:182
def fail(self, measRecord, error=None)
Definition: plugins.py:300
def __init__(self, config, name, schema, metadata)
Definition: plugins.py:166
def measure(self, measRecord, exposure)
Definition: plugins.py:134
Base class for configs of single-frame plugin algorithms.
Definition: sfm.py:43
def __init__(self, config, name, schemaMapper, metadata)
Definition: plugins.py:397
def fail(self, measRecord, error=None)
Definition: plugins.py:245
Base class for single-frame plugin algorithms.
Definition: sfm.py:50
def fail(self, measRecord, error=None)
Definition: plugins.py:145
def __init__(self, config, name, schema, metadata)
Definition: plugins.py:278
def register(name, shouldApCorr=False, apCorrList=())
A Python decorator that registers a class, using the given name, in its base class&#39;s PluginRegistry...
def measure(self, measRecord, exposure)
Definition: plugins.py:173
def measure(self, measRecord, exposure)
Definition: plugins.py:219
def measure(self, measRecord, exposure, refRecord, refWcs)
Definition: plugins.py:453
def __init__(self, config, name, schemaMapper, metadata)
Definition: plugins.py:435
def __init__(self, config, name, schemaMapper, metadata)
Definition: plugins.py:482
def wrapTransform(transformClass, hasLogName=False)
Definition: wrappers.py:425
def measure(self, measRecord, exposure, refRecord, refWcs)
Definition: plugins.py:403
def __init__(self, config, name, schema, metadata)
Definition: plugins.py:327
def __init__(self, config, name, schema, metadata)
Definition: plugins.py:208
def measure(self, measRecord, exposure)
Definition: plugins.py:363
def measure(self, measRecord, exposure)
Definition: plugins.py:290
def measure(self, measRecord, exposure, refRecord, refWcs)
Definition: plugins.py:502
def wrapSimpleAlgorithm(AlgClass, executionOrder, name=None, needsMetadata=False, hasMeasureN=False, hasLogName=False, kwds)
Wrap a C++ SimpleAlgorithm class into both a Python SingleFramePlugin and ForcedPlugin classes...
Definition: wrappers.py:354