LSSTApplications  8.0.0.0+107,8.0.0.1+13,9.1+18,9.2,master-g084aeec0a4,master-g0aced2eed8+6,master-g15627eb03c,master-g28afc54ef9,master-g3391ba5ea0,master-g3d0fb8ae5f,master-g4432ae2e89+36,master-g5c3c32f3ec+17,master-g60f1e072bb+1,master-g6a3ac32d1b,master-g76a88a4307+1,master-g7bce1f4e06+57,master-g8ff4092549+31,master-g98e65bf68e,master-ga6b77976b1+53,master-gae20e2b580+3,master-gb584cd3397+53,master-gc5448b162b+1,master-gc54cf9771d,master-gc69578ece6+1,master-gcbf758c456+22,master-gcec1da163f+63,master-gcf15f11bcc,master-gd167108223,master-gf44c96c709
LSSTDataManagementBasePackage
Classes | Functions | Variables
lsst.meas.base.wrappers Namespace Reference

Classes

class  WrappedSingleFramePlugin
 
class  WrappedForcedPlugin
 

Functions

def wrapAlgorithmControl
 Wrap a C++ algorithm's control class into a Python Config class. More...
 
def wrapAlgorithm
 Wrap a C++ Algorithm class into a Python Plugin class. More...
 
def wrapSingleFrameAlgorithm
 Wrap a C++ SingleFrameAlgorithm class into a Python SingleFramePlugin class. More...
 
def wrapForcedAlgorithm
 Wrap a C++ ForcedAlgorithm class into a Python ForcedPlugin class. More...
 
def wrapSimpleAlgorithm
 Wrap a C++ SimpleAlgorithm class into both a Python SingleFramePlugin and ForcedPlugin classes. More...
 

Variables

tuple __all__ = ("wrapSingleFrameAlgorithm", "wrapForcedAlgorithm", "wrapSimpleAlgorithm")
 

Function Documentation

def lsst.meas.base.wrappers.wrapAlgorithm (   Base,
  AlgClass,
  factory,
  name = None,
  Control = None,
  ConfigClass = None,
  doRegister = True,
  kwds 
)

Wrap a C++ Algorithm class into a Python Plugin class.

Parameters
[in]BaseBase class for the returned Plugin; one of SingleFramePlugin or ForcedPlugin
[in]AlgClassSwigged C++ Algorithm class to convert; must be a subclass of SingleFrameAlgorithm or ForcedAlgorithm (matching the Base argument), or an unrelated class with the same measure() and measureN() signatures as those base classes.
[in]factoryA callable that is used to construct an instance of AlgClass. It must take four arguments, either (config, name, schema, metadata) or (config, name, schemaMapper, metadata), depending on whether the algorithm is single-frame or forced.
[in]nameString to use when registering the algorithm. Ignored if doRegistry=False, set to generateAlgorithmName(AlgClass) if None.
[in]ControlSwigged C++ Control class for the algorithm; AlgClass.Control is used if None. Ignored if ConfigClass is not None.
[in]ConfigClassPython Config class that wraps the C++ Algorithm's swigged Control class. If None, wrapAlgorithmControl is called to generate a Config class using the Control argument.
[in]doRegisterIf True (the default), register the plugin with Base's registry, allowing it to be used by measurement Tasks.
[in]**kwdsAdditional keyword arguments passed to generateAlgorithmControl, including:
  • hasMeasureN: Whether the plugin supports fitting multiple objects at once (if so, a config option to enable/disable this will be added).
  • executionOrder: If not None, an override for the default executionOrder for this plugin (the default is 2.0, which is usually appropriate for fluxes).
Returns
the new Plugin class, a subclass of Base

This function is generally only called by the public wrapSingleFrameAlgorithm, wrapForcedAlgorithm, and wrapSimpleAlgorithm functions; it is unlikely users will have to call it directly.

Definition at line 80 of file wrappers.py.

80 
81  **kwds):
82  """!
83  Wrap a C++ Algorithm class into a Python Plugin class.
84 
85  @param[in] Base Base class for the returned Plugin; one of SingleFramePlugin or
86  ForcedPlugin
87  @param[in] AlgClass Swigged C++ Algorithm class to convert; must be a subclass of
88  SingleFrameAlgorithm or ForcedAlgorithm (matching the Base argument), or
89  an unrelated class with the same measure() and measureN() signatures as
90  those base classes.
91  @param[in] factory A callable that is used to construct an instance of AlgClass. It must take
92  four arguments, either (config, name, schema, metadata) or
93  (config, name, schemaMapper, metadata), depending on whether the algorithm is
94  single-frame or forced.
95  @param[in] name String to use when registering the algorithm. Ignored if doRegistry=False,
96  set to generateAlgorithmName(AlgClass) if None.
97  @param[in] Control Swigged C++ Control class for the algorithm; AlgClass.Control is used if None.
98  Ignored if ConfigClass is not None.
99  @param[in] ConfigClass Python Config class that wraps the C++ Algorithm's swigged Control class. If
100  None, wrapAlgorithmControl is called to generate a Config class using the
101  Control argument.
102  @param[in] doRegister If True (the default), register the plugin with Base's registry, allowing it
103  to be used by measurement Tasks.
104  @param[in] **kwds Additional keyword arguments passed to generateAlgorithmControl, including:
105  - hasMeasureN: Whether the plugin supports fitting multiple objects at once
106  (if so, a config option to enable/disable this will be added).
107  - executionOrder: If not None, an override for the default executionOrder for
108  this plugin (the default is 2.0, which is usually appropriate for fluxes).
109 
110  @return the new Plugin class, a subclass of Base
111 
112  This function is generally only called by the public wrapSingleFrameAlgorithm, wrapForcedAlgorithm, and
113  wrapSimpleAlgorithm functions; it is unlikely users will have to call it directly.
114  """
115  if ConfigClass is None:
116  if Control is None:
117  Control = AlgClass.Control
118  ConfigClass = wrapAlgorithmControl(Base.ConfigClass, Control, **kwds)
119  PluginClass = type(AlgClass.__name__ + Base.__name__, (Base,),
120  dict(AlgClass=AlgClass, ConfigClass=ConfigClass, factory=staticmethod(factory)))
121  if doRegister:
122  if name is None:
123  name = generateAlgorithmName(AlgClass)
124  Base.registry.register(name, PluginClass)
125  return PluginClass
126 
lsst::meas::base.base.generateAlgorithmName
def generateAlgorithmName
Definition: base.py:40
lsst::meas::base.wrappers.wrapAlgorithmControl
def wrapAlgorithmControl
Wrap a C++ algorithm's control class into a Python Config class.
Definition: wrappers.py:42
def lsst.meas.base.wrappers.wrapAlgorithmControl (   Base,
  Control,
  hasMeasureN = False,
  executionOrder = None 
)

Wrap a C++ algorithm's control class into a Python Config class.

Parameters
[in]BaseBase class for the returned ConfigClass; one of SingleFramePluginConfig or ForcedPluginConfig
[in]ControlControl class to be wrapped (a Swigged C++ class)
[in]hasMeasureNWhether the plugin supports fitting multiple objects at once (if so, a config option to enable/disable this will be added).
[in]executionOrderIf not None, an override for the default executionOrder for this plugin.
Returns
a new subclass of lsst.pex.config.Config

This function is generally only called by wrapAlgorithm; it is unlikely users will have to call it directly.

Definition at line 42 of file wrappers.py.

42 
43 def wrapAlgorithmControl(Base, Control, hasMeasureN=False, executionOrder=None):
44  """!
45  Wrap a C++ algorithm's control class into a Python Config class.
46 
47  @param[in] Base Base class for the returned ConfigClass; one of SingleFramePluginConfig or
48  ForcedPluginConfig
49  @param[in] Control Control class to be wrapped (a Swigged C++ class)
50  @param[in] hasMeasureN Whether the plugin supports fitting multiple objects at once (if so, a
51  config option to enable/disable this will be added).
52  @param[in] executionOrder If not None, an override for the default executionOrder for this plugin.
53 
54  @return a new subclass of lsst.pex.config.Config
55 
56  This function is generally only called by wrapAlgorithm; it is unlikely users will have to call it
57  directly.
58  """
59  if hasMeasureN:
60  # We need to add a Config field to enable multi-object measurement, to replace
61  # the simple bool class attribute that's on the base class. To do that, we
62  # create the Config class dynamically here, then call makeControlClass to finish
63  # it off by adding fields from the control object.
64  cls = type(
65  Control.__name__.replace("Control", "Config"),
66  (Base,),
67  {"doMeasureN": lsst.pex.config.Field(dtype=bool, default=True,
68  doc="whether to run this plugin in multi-object mode")}
69  )
70  ConfigClass = lsst.pex.config.makeConfigClass(Control, module=Control.__module__, cls=cls)
71  else:
72  # If we don't have to add that Config field, we can delegate all of the work to
73  # pex_config's makeControlClass
74  ConfigClass = lsst.pex.config.makeConfigClass(Control, module=Control.__module__, base=Base)
75  if executionOrder is not None:
76  ConfigClass.executionOrder.default = float(executionOrder)
77  return ConfigClass
78 
lsst::meas::base.wrappers.wrapAlgorithmControl
def wrapAlgorithmControl
Wrap a C++ algorithm's control class into a Python Config class.
Definition: wrappers.py:42
def lsst.meas.base.wrappers.wrapForcedAlgorithm (   AlgClass,
  name = None,
  needsMetadata = False,
  hasMeasureN = False,
  needsSchemaOnly = False,
  kwds 
)

Wrap a C++ ForcedAlgorithm class into a Python ForcedPlugin class.

Parameters
[in]AlgClassSwigged C++ Algorithm class to convert; must be a subclass of ForcedAlgorithm, or an unrelated class with the same measure(), measureN(), and fail() signatures.
[in]nameString to use when registering the algorithm. Ignored if doRegistry=False, set to generateAlgorithmName(AlgClass) if None.
[in]needsMetadataSets whether the AlgClass's constructor should be passed a PropertySet metadata argument.
[in]hasMeasureNWhether the algorithm supports simultaneous measurement of multiple sources. If True, a bool doMeasureN field will be added to the generated Config class, and its value will be passed as the last argument when calling the AlgClass constructor.
[in]needsSchemaOnlyWhether the algorithm constructor expects a Schema argument (representing the output Schema) rather than the full SchemaMapper (which provides access to both the reference Schema and the output Schema).
[in]**kwdsAdditional keyword arguments passed to the lower-level wrapAlgorithm and wrapAlgorithmControl classes. These include:
  • Control: Swigged C++ Control class for the algorithm; AlgClass.Control is used if None. Ignored if ConfigClass is not None.
  • ConfigClass: Python Config class that wraps the C++ Algorithm's swigged Control class. If None, wrapAlgorithmControl is called to generate a Config class using the Control argument.
  • doRegister: If True (the default), register the plugin with ForcedPlugin.registry, allowing it to be used by ForcedMeasurementTask.
  • executionOrder: If not None, an override for the default executionOrder for this plugin (the default is 2.0, which is usually appropriate for fluxes).
Returns
the new ForcedPlugin subclass

The needsMetadata, hasMeasureN, and needsSchemaOnly arguments combine to determine the expected constructor signature; we always expect the first two arguments to be: 

Control const & ctrl, std::string const & name

If needsSchemaOnly is True, then the third argument will be 

Schema & schema

otherwise, it will be: 

SchemaMapper & schemaMapper

If needsMetadata, we also append: 

PropertySet & metadata

If hasMeasureN, we also append: 

bool doMeasureN

If both are True, the metadata PropertySet precedes the doMeasureN bool.

Definition at line 191 of file wrappers.py.

191 
192  **kwds):
193  """!
194  Wrap a C++ ForcedAlgorithm class into a Python ForcedPlugin class.
195 
196  @param[in] AlgClass Swigged C++ Algorithm class to convert; must be a subclass of
197  ForcedAlgorithm, or an unrelated class with the same measure(), measureN(),
198  and fail() signatures.
199  @param[in] name String to use when registering the algorithm. Ignored if doRegistry=False,
200  set to generateAlgorithmName(AlgClass) if None.
201  @param[in] needsMetadata Sets whether the AlgClass's constructor should be passed a PropertySet
202  metadata argument.
203  @param[in] hasMeasureN Whether the algorithm supports simultaneous measurement of multiple sources.
204  If True, a bool doMeasureN field will be added to the generated Config class,
205  and its value will be passed as the last argument when calling the AlgClass
206  constructor.
207  @param[in] needsSchemaOnly Whether the algorithm constructor expects a Schema argument (representing the
208  output Schema) rather than the full SchemaMapper (which provides access to
209  both the reference Schema and the output Schema).
210  @param[in] **kwds Additional keyword arguments passed to the lower-level wrapAlgorithm and
211  wrapAlgorithmControl classes. These include:
212  - Control: Swigged C++ Control class for the algorithm; AlgClass.Control
213  is used if None. Ignored if ConfigClass is not None.
214  - ConfigClass: Python Config class that wraps the C++ Algorithm's swigged
215  Control class. If None, wrapAlgorithmControl is called to generate a
216  Config class using the Control argument.
217  - doRegister: If True (the default), register the plugin with
218  ForcedPlugin.registry, allowing it to be used by ForcedMeasurementTask.
219  - executionOrder: If not None, an override for the default executionOrder for
220  this plugin (the default is 2.0, which is usually appropriate for fluxes).
221 
222  @return the new ForcedPlugin subclass
223 
224  The needsMetadata, hasMeasureN, and needsSchemaOnly arguments combine to determine the expected
225  constructor signature; we always expect the first two arguments to be:
226  @verbatim
227  Control const & ctrl, std::string const & name
228  @endverbatim
229  If needsSchemaOnly is True, then the third argument will be
230  @verbatim
231  Schema & schema
232  @endverbatim
233  otherwise, it will be:
234  @verbatim
235  SchemaMapper & schemaMapper
236  @endverbatim
237  If needsMetadata, we also append:
238  @verbatim
239  PropertySet & metadata
240  @endverbatim
241  If hasMeasureN, we also append:
242  @verbatim
243  bool doMeasureN
244  @endverbatim
245  If both are True, the metadata PropertySet precedes the doMeasureN bool.
246  """
247  if needsSchemaOnly:
248  extractSchemaArg = lambda m: m.editOutputSchema()
249  else:
250  extractSchemaArg = lambda m: m
251  if hasMeasureN:
252  if needsMetadata:
253  def factory(config, name, schemaMapper, metadata):
254  return AlgClass(config.makeControl(), name, extractSchemaArg(schemaMapper),
255  metadata, config.doMeasureN)
256  else:
257  def factory(config, name, schemaMapper, metadata):
258  return AlgClass(config.makeControl(), name, extractSchemaArg(schemaMapper),
259  config.doMeasureN)
260  else:
261  if needsMetadata:
262  def factory(config, name, schemaMapper, metadata):
263  return AlgClass(config.makeControl(), name, extractSchemaArg(schemaMapper),
264  metadata)
265  else:
266  def factory(config, name, schemaMapper, metadata):
267  return AlgClass(config.makeControl(), name, extractSchemaArg(schemaMapper))
268  return wrapAlgorithm(WrappedForcedPlugin, AlgClass, factory=factory, **kwds)
269 
lsst::meas::base.wrappers.wrapAlgorithm
def wrapAlgorithm
Wrap a C++ Algorithm class into a Python Plugin class.
Definition: wrappers.py:80
def lsst.meas.base.wrappers.wrapSimpleAlgorithm (   AlgClass,
  name = None,
  needsMetadata = False,
  hasMeasureN = False,
  kwds 
)

Wrap a C++ SimpleAlgorithm class into both a Python SingleFramePlugin and ForcedPlugin classes.

Parameters
[in]AlgClassSwigged C++ Algorithm class to convert; must be a subclass of simpleAlgorithm, or an unrelated class with the same measure(), measureN(), and fail() signatures.
[in]nameString to use when registering the algorithm. Ignored if doRegistry=False, set to generateAlgorithmName(AlgClass) if None.
[in]needsMetadataSets whether the AlgClass's constructor should be passed a PropertySet metadata argument.
[in]hasMeasureNWhether the algorithm supports simultaneous measurement of multiple sources. If True, a bool doMeasureN field will be added to the generated Config class, and its value will be passed as the last argument when calling the AlgClass constructor.
[in]**kwdsAdditional keyword arguments passed to the lower-level wrapAlgorithm and wrapAlgorithmControl classes. These include:
  • Control: Swigged C++ Control class for the algorithm; AlgClass.Control is used if None. Ignored if ConfigClass is not None.
  • ConfigClass: Python Config class that wraps the C++ Algorithm's swigged Control class. If None, wrapAlgorithmControl is called to generate a Config class using the Control argument.
  • doRegister: If True (the default), register the plugins with Base's registry, allowing it to be used by measurement Tasks.
  • executionOrder: If not None, an override for the default executionOrder for this plugin (the default is 2.0, which is usually appropriate for fluxes).
Returns
a two-element tuple, containing the new SingleFramePlugin and ForcedPlugin subclasses

The needsMetadata and hasMeasureN arguments combine to determine the expected constructor signature; we always expect the first three arguments to be: 

Control const & ctrl, std::string const & name, Schema & schema

If needsMetadata, we also append: 

PropertySet & metadata

If hasMeasureN, we also append: 

bool doMeasureN

If both are True, the metadata PropertySet precedes the doMeasureN bool.

Definition at line 270 of file wrappers.py.

270 
271 def wrapSimpleAlgorithm(AlgClass, name=None, needsMetadata=False, hasMeasureN=False, **kwds):
272  """!
273  Wrap a C++ SimpleAlgorithm class into both a Python SingleFramePlugin and ForcedPlugin classes
274 
275  @param[in] AlgClass Swigged C++ Algorithm class to convert; must be a subclass of
276  simpleAlgorithm, or an unrelated class with the same measure(), measureN(),
277  and fail() signatures.
278  @param[in] name String to use when registering the algorithm. Ignored if doRegistry=False,
279  set to generateAlgorithmName(AlgClass) if None.
280  @param[in] needsMetadata Sets whether the AlgClass's constructor should be passed a PropertySet
281  metadata argument.
282  @param[in] hasMeasureN Whether the algorithm supports simultaneous measurement of multiple sources.
283  If True, a bool doMeasureN field will be added to the generated Config class,
284  and its value will be passed as the last argument when calling the AlgClass
285  constructor.
286  @param[in] **kwds Additional keyword arguments passed to the lower-level wrapAlgorithm and
287  wrapAlgorithmControl classes. These include:
288  - Control: Swigged C++ Control class for the algorithm; AlgClass.Control
289  is used if None. Ignored if ConfigClass is not None.
290  - ConfigClass: Python Config class that wraps the C++ Algorithm's swigged
291  Control class. If None, wrapAlgorithmControl is called to generate a
292  Config class using the Control argument.
293  - doRegister: If True (the default), register the plugins with Base's
294  registry, allowing it to be used by measurement Tasks.
295  - executionOrder: If not None, an override for the default executionOrder for
296  this plugin (the default is 2.0, which is usually appropriate for fluxes).
297 
298  @return a two-element tuple, containing the new SingleFramePlugin and ForcedPlugin subclasses
299 
300  The needsMetadata and hasMeasureN arguments combine to determine the expected constructor signature;
301  we always expect the first three arguments to be:
302  @verbatim
303  Control const & ctrl, std::string const & name, Schema & schema
304  @endverbatim
305  If needsMetadata, we also append:
306  @verbatim
307  PropertySet & metadata
308  @endverbatim
309  If hasMeasureN, we also append:
310  @verbatim
311  bool doMeasureN
312  @endverbatim
313  If both are True, the metadata PropertySet precedes the doMeasureN bool.
314  """
315  return (wrapSingleFrameAlgorithm(AlgClass, name=name, needsMetadata=needsMetadata, **kwds),
316  wrapForcedAlgorithm(AlgClass, name=name, needsMetadata=needsMetadata,
317  needsSchemaOnly=True, **kwds))
lsst::meas::base.wrappers.wrapSingleFrameAlgorithm
def wrapSingleFrameAlgorithm
Wrap a C++ SingleFrameAlgorithm class into a Python SingleFramePlugin class.
Definition: wrappers.py:127
lsst::meas::base.wrappers.wrapForcedAlgorithm
def wrapForcedAlgorithm
Wrap a C++ ForcedAlgorithm class into a Python ForcedPlugin class.
Definition: wrappers.py:191
lsst::meas::base.wrappers.wrapSimpleAlgorithm
def wrapSimpleAlgorithm
Wrap a C++ SimpleAlgorithm class into both a Python SingleFramePlugin and ForcedPlugin classes...
Definition: wrappers.py:270
def lsst.meas.base.wrappers.wrapSingleFrameAlgorithm (   AlgClass,
  name = None,
  needsMetadata = False,
  hasMeasureN = False,
  kwds 
)

Wrap a C++ SingleFrameAlgorithm class into a Python SingleFramePlugin class.

Parameters
[in]AlgClassSwigged C++ Algorithm class to convert; must be a subclass of SingleFrameAlgorithm, or an unrelated class with the same measure(), measureN(), and fail() signatures.
[in]nameString to use when registering the algorithm. Ignored if doRegistry=False, set to generateAlgorithmName(AlgClass) if None.
[in]needsMetadataSets whether the AlgClass's constructor should be passed a PropertySet metadata argument.
[in]hasMeasureNWhether the algorithm supports simultaneous measurement of multiple sources. If True, a bool doMeasureN field will be added to the generated Config class, and its value will be passed as the last argument when calling the AlgClass constructor.
[in]**kwdsAdditional keyword arguments passed to the lower-level wrapAlgorithm and wrapAlgorithmControl classes. These include:
  • Control: Swigged C++ Control class for the algorithm; AlgClass.Control is used if None. Ignored if ConfigClass is not None.
  • ConfigClass: Python Config class that wraps the C++ Algorithm's swigged Control class. If None, wrapAlgorithmControl is called to generate a Config class using the Control argument.
  • doRegister: If True (the default), register the plugin with SingleFramePlugin.registry, allowing it to be used by SingleFrameMeasurementTask.
  • executionOrder: If not None, an override for the default executionOrder for this plugin (the default is 2.0, which is usually appropriate for fluxes).
Returns
the new SingleFramePlugin subclass

The needsMetadata and hasMeasureN arguments combine to determine the expected constructor signature; we always expect the first three arguments to be: 

Control const & ctrl, std::string const & name, Schema & schema

If needsMetadata, we also append: 

PropertySet & metadata

If hasMeasureN, we also append: 

bool doMeasureN

If both are True, the metadata PropertySet precedes the doMeasureN bool.

Definition at line 127 of file wrappers.py.

127 
128 def wrapSingleFrameAlgorithm(AlgClass, name=None, needsMetadata=False, hasMeasureN=False, **kwds):
129  """!
130  Wrap a C++ SingleFrameAlgorithm class into a Python SingleFramePlugin class.
131 
132  @param[in] AlgClass Swigged C++ Algorithm class to convert; must be a subclass of
133  SingleFrameAlgorithm, or an unrelated class with the same measure(),
134  measureN(), and fail() signatures.
135  @param[in] name String to use when registering the algorithm. Ignored if doRegistry=False,
136  set to generateAlgorithmName(AlgClass) if None.
137  @param[in] needsMetadata Sets whether the AlgClass's constructor should be passed a PropertySet
138  metadata argument.
139  @param[in] hasMeasureN Whether the algorithm supports simultaneous measurement of multiple sources.
140  If True, a bool doMeasureN field will be added to the generated Config class,
141  and its value will be passed as the last argument when calling the AlgClass
142  constructor.
143  @param[in] **kwds Additional keyword arguments passed to the lower-level wrapAlgorithm and
144  wrapAlgorithmControl classes. These include:
145  - Control: Swigged C++ Control class for the algorithm; AlgClass.Control
146  is used if None. Ignored if ConfigClass is not None.
147  - ConfigClass: Python Config class that wraps the C++ Algorithm's swigged
148  Control class. If None, wrapAlgorithmControl is called to generate a
149  Config class using the Control argument.
150  - doRegister: If True (the default), register the plugin with
151  SingleFramePlugin.registry, allowing it to be used by
152  SingleFrameMeasurementTask.
153  - executionOrder: If not None, an override for the default executionOrder for
154  this plugin (the default is 2.0, which is usually appropriate for fluxes).
155 
156  @return the new SingleFramePlugin subclass
157 
158  The needsMetadata and hasMeasureN arguments combine to determine the expected constructor signature;
159  we always expect the first three arguments to be:
160  @verbatim
161  Control const & ctrl, std::string const & name, Schema & schema
162  @endverbatim
163  If needsMetadata, we also append:
164  @verbatim
165  PropertySet & metadata
166  @endverbatim
167  If hasMeasureN, we also append:
168  @verbatim
169  bool doMeasureN
170  @endverbatim
171  If both are True, the metadata PropertySet precedes the doMeasureN bool.
172  """
173  if hasMeasureN:
174  if needsMetadata:
175  def factory(config, name, schema, metadata):
176  return AlgClass(config.makeControl(), name, schema, metadata, config.doMeasureN)
177  else:
178  def factory(config, name, schema, metadata):
179  return AlgClass(config.makeControl(), name, schema, config.doMeasureN)
180  else:
181  if needsMetadata:
182  def factory(config, name, schema, metadata):
183  return AlgClass(config.makeControl(), name, schema, metadata)
184  else:
185  def factory(config, name, schema, metadata):
186  return AlgClass(config.makeControl(), name, schema)
187  return wrapAlgorithm(WrappedSingleFramePlugin, AlgClass, factory=factory,
188  hasMeasureN=hasMeasureN, **kwds)
189 
lsst::meas::base.wrappers.wrapSingleFrameAlgorithm
def wrapSingleFrameAlgorithm
Wrap a C++ SingleFrameAlgorithm class into a Python SingleFramePlugin class.
Definition: wrappers.py:127
lsst::meas::base.wrappers.wrapAlgorithm
def wrapAlgorithm
Wrap a C++ Algorithm class into a Python Plugin class.
Definition: wrappers.py:80

Variable Documentation

tuple lsst.meas.base.wrappers.__all__ = ("wrapSingleFrameAlgorithm", "wrapForcedAlgorithm", "wrapSimpleAlgorithm")

Definition at line 7 of file wrappers.py.

Generated on Mon Dec 8 2014 18:37:23 for LSSTApplications by   doxygen 1.8.5