LSSTApplications  20.0.0
LSSTDataManagementBasePackage
apertureFlux.cc
Go to the documentation of this file.
1 /*
2  * LSST Data Management System
3  * Copyright 2008-2017 AURA/LSST.
4  *
5  * This product includes software developed by the
6  * LSST Project (http://www.lsst.org/).
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the LSST License Statement and
19  * the GNU General Public License along with this program. If not,
20  * see <https://www.lsstcorp.org/LegalNotices/>.
21  */
22 
23 #include "pybind11/pybind11.h"
24 #include "pybind11/stl.h"
25 
26 #include <memory>
27 
28 #include "lsst/pex/config/python.h"
29 #include "lsst/meas/base/python.h"
30 
33 
34 namespace py = pybind11;
35 using namespace pybind11::literals;
36 
37 namespace lsst {
38 namespace meas {
39 namespace base {
40 
41 namespace {
42 
43 using PyFluxAlgorithm =
44  py::class_<ApertureFluxAlgorithm, std::shared_ptr<ApertureFluxAlgorithm>, SimpleAlgorithm>;
45 using PyFluxControl = py::class_<ApertureFluxControl>;
46 using PyFluxResult = py::class_<ApertureFluxResult, std::shared_ptr<ApertureFluxResult>, FluxResult>;
47 using PyFluxTransform =
48  py::class_<ApertureFluxTransform, std::shared_ptr<ApertureFluxTransform>, BaseTransform>;
49 
50 PyFluxControl declareFluxControl(py::module &mod) {
51  PyFluxControl cls(mod, "ApertureFluxControl");
52 
53  LSST_DECLARE_CONTROL_FIELD(cls, ApertureFluxControl, radii);
54  LSST_DECLARE_CONTROL_FIELD(cls, ApertureFluxControl, maxSincRadius);
55  LSST_DECLARE_CONTROL_FIELD(cls, ApertureFluxControl, shiftKernel);
56 
57  cls.def(py::init<>());
58 
59  return cls;
60 }
61 
62 template <typename Image, class PyClass>
63 void declareComputeFluxes(PyClass &cls) {
65  using Result = ApertureFluxAlgorithm::Result;
66 
67  cls.def_static("computeSincFlux",
68  (Result(*)(Image const &, afw::geom::ellipses::Ellipse const &, Control const &)) &
69  ApertureFluxAlgorithm::computeSincFlux,
70  "image"_a, "ellipse"_a, "ctrl"_a = Control());
71  cls.def_static("computeNaiveFlux",
72  (Result(*)(Image const &, afw::geom::ellipses::Ellipse const &, Control const &)) &
73  ApertureFluxAlgorithm::computeNaiveFlux,
74  "image"_a, "ellipse"_a, "ctrl"_a = Control());
75  cls.def_static("computeFlux",
76  (Result(*)(Image const &, afw::geom::ellipses::Ellipse const &, Control const &)) &
77  ApertureFluxAlgorithm::computeFlux,
78  "image"_a, "ellipse"_a, "ctrl"_a = Control());
79 }
80 
81 PyFluxAlgorithm declareFluxAlgorithm(py::module &mod) {
82  PyFluxAlgorithm cls(mod, "ApertureFluxAlgorithm");
83 
84  cls.attr("FAILURE") = py::cast(ApertureFluxAlgorithm::FAILURE);
85  cls.attr("APERTURE_TRUNCATED") = py::cast(ApertureFluxAlgorithm::APERTURE_TRUNCATED);
86  cls.attr("SINC_COEFFS_TRUNCATED") = py::cast(ApertureFluxAlgorithm::SINC_COEFFS_TRUNCATED);
87 
88  // constructor not wrapped because class is abstract
89 
90  declareComputeFluxes<afw::image::Image<double>>(cls);
91  declareComputeFluxes<afw::image::MaskedImage<double>>(cls);
92  declareComputeFluxes<afw::image::Image<float>>(cls);
93  declareComputeFluxes<afw::image::MaskedImage<float>>(cls);
94 
95  cls.def("measure", &ApertureFluxAlgorithm::measure, "measRecord"_a, "exposure"_a);
96  cls.def("fail", &ApertureFluxAlgorithm::fail, "measRecord"_a, "error"_a = nullptr);
97  cls.def_static("makeFieldPrefix", &ApertureFluxAlgorithm::makeFieldPrefix, "name"_a, "radius"_a);
98 
99  return cls;
100 }
101 
102 void declareFluxResult(py::module &mod) {
103  PyFluxResult cls(mod, "ApertureFluxResult");
104 
105  cls.def("getFlag", (bool (ApertureFluxResult::*)(unsigned int) const) & ApertureFluxResult::getFlag,
106  "bit"_a);
107  cls.def("getFlag",
108  (bool (ApertureFluxResult::*)(std::string const &name) const) & ApertureFluxResult::getFlag,
109  "name"_a);
110  cls.def("setFlag", &ApertureFluxResult::setFlag, "index"_a, "value"_a);
111  cls.def("unsetFlag", &ApertureFluxResult::unsetFlag, "index"_a);
112 }
113 
114 PyFluxTransform declareFluxTransform(py::module &mod) {
115  PyFluxTransform cls(mod, "ApertureFluxTransform");
116 
118  afw::table::SchemaMapper &>(),
119  "ctrl"_a, "name"_a, "mapper"_a);
120 
121  cls.def("__call__", &ApertureFluxTransform::operator(), "inputCatalog"_a, "outputCatalog"_a, "wcs"_a,
122  "photoCalib"_a);
123 
124  return cls;
125 }
126 
127 } // namespace
128 
129 PYBIND11_MODULE(apertureFlux, mod) {
130  py::module::import("lsst.afw.geom");
131  py::module::import("lsst.afw.image");
132  py::module::import("lsst.afw.table");
133  py::module::import("lsst.meas.base.algorithm");
134  py::module::import("lsst.meas.base.flagHandler");
135  py::module::import("lsst.meas.base.fluxUtilities");
136  py::module::import("lsst.meas.base.transform");
137 
138  auto clsFluxControl = declareFluxControl(mod);
139  auto clsFluxAlgorithm = declareFluxAlgorithm(mod);
140  declareFluxResult(mod);
141  auto clsFluxTransform = declareFluxTransform(mod);
142 
143  clsFluxAlgorithm.attr("Control") = clsFluxControl;
144  // no need to make ApertureFluxControl::Result visible to Python
145  clsFluxTransform.attr("Control") = clsFluxControl;
146 
147  python::declareAlgorithm<ApertureFluxAlgorithm, ApertureFluxControl, ApertureFluxTransform>(
148  clsFluxAlgorithm, clsFluxControl, clsFluxTransform);
149 }
150 
151 } // namespace base
152 } // namespace meas
153 } // namespace lsst
std::string
STL class.
base
Definition: __init__.py:1
lsst::meas::base.plugins.BaseTransform
BaseTransform
Definition: plugins.py:98
FluxUtilities.h
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::meas::base::PYBIND11_MODULE
PYBIND11_MODULE(apertureFlux, mod)
Definition: apertureFlux.cc:129
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
ApertureFlux.h
PyClass
py::class_< ProductBoundedField, std::shared_ptr< ProductBoundedField >, BoundedField > PyClass
Definition: productBoundedField.cc:32
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
python.h
LSST_DECLARE_CONTROL_FIELD
#define LSST_DECLARE_CONTROL_FIELD(WRAPPER, CLASS, NAME)
Macro used to wrap fields declared by LSST_CONTROL_FIELD using Pybind11.
Definition: python.h:50
pybind11
Definition: _GenericMap.cc:40
python.h
lsst::utils.tests.init
def init()
Definition: tests.py:58
lsst::ip::isr.fringe.measure
def measure(mi, x, y, size, statistic, stats)
Definition: fringe.py:506
lsst::ip::diffim.Control
Control
Definition: __init__.py:49
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42