LSSTApplications  20.0.0
LSSTDataManagementBasePackage
dipoleAlgorithms.cc
Go to the documentation of this file.
1 /*
2  * LSST Data Management System
3  *
4  * This product includes software developed by the
5  * LSST Project (http://www.lsst.org/).
6  * See the COPYRIGHT file
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 #include <string>
28 
31 #include "lsst/pex/config/python.h" // for LSST_DECLARE_CONTROL_FIELD
32 
33 namespace py = pybind11;
34 using namespace pybind11::literals;
35 
36 namespace lsst {
37 namespace ip {
38 namespace diffim {
39 
40 namespace {
41 
42 void declareDipoleCentroidControl(py::module &mod) {
43  py::class_<DipoleCentroidControl, std::shared_ptr<DipoleCentroidControl>> cls(mod,
44  "DipoleCentroidControl");
45 
46  cls.def(py::init<>());
47 }
48 
49 void declareDipoleFluxControl(py::module &mod) {
50  py::class_<DipoleFluxControl, std::shared_ptr<DipoleFluxControl>> cls(mod, "DipoleFluxControl");
51 
52  cls.def(py::init<>());
53 }
54 
55 void declareDipolePsfFluxControl(py::module &mod) {
56  py::class_<PsfDipoleFluxControl, std::shared_ptr<PsfDipoleFluxControl>, DipoleFluxControl> cls(
57  mod, "PsfDipoleFluxControl");
58 
59  cls.def(py::init<>());
60 
65 }
66 
67 void declareDipoleCentroidAlgorithm(py::module &mod) {
68  // Abstract class, so add a leading underscore to Python name and do not wrap constructor
69  py::class_<DipoleCentroidAlgorithm, std::shared_ptr<DipoleCentroidAlgorithm>, meas::base::SimpleAlgorithm>
70  cls(mod, "_DipoleCentroidAlgorithm");
71 
72  cls.attr("FAILURE") = py::cast(DipoleCentroidAlgorithm::FAILURE);
73  cls.attr("POS_FLAG") = py::cast(DipoleCentroidAlgorithm::POS_FLAG);
74  cls.attr("NEG_FLAG") = py::cast(DipoleCentroidAlgorithm::NEG_FLAG);
75  cls.def_static("getFlagDefinitions", &DipoleCentroidAlgorithm::getFlagDefinitions,
76  py::return_value_policy::copy);
77 
78  cls.def("getPositiveKeys", &DipoleCentroidAlgorithm::getPositiveKeys);
79  cls.def("getNegativeKeys", &DipoleCentroidAlgorithm::getNegativeKeys);
80 }
81 
82 void declareDipoleFluxAlgorithm(py::module &mod) {
83  // Abstract class, so add a leading underscore to Python name and do not wrap constructor
84  py::class_<DipoleFluxAlgorithm, std::shared_ptr<DipoleFluxAlgorithm>, meas::base::SimpleAlgorithm> cls(
85  mod, "_DipoleFluxAlgorithm");
86 
87  cls.attr("FAILURE") = py::cast(DipoleFluxAlgorithm::FAILURE);
88  cls.attr("POS_FLAG") = py::cast(DipoleFluxAlgorithm::POS_FLAG);
89  cls.attr("NEG_FLAG") = py::cast(DipoleFluxAlgorithm::NEG_FLAG);
90  cls.def_static("getFlagDefinitions", &DipoleFluxAlgorithm::getFlagDefinitions,
91  py::return_value_policy::copy);
92 
93  cls.def("getPositiveKeys", &DipoleFluxAlgorithm::getPositiveKeys);
94  cls.def("getNegativeKeys", &DipoleFluxAlgorithm::getNegativeKeys);
95 }
96 
97 void declareNaiveDipoleFlux(py::module &mod) {
98  py::module::import("lsst.meas.base");
99 
100  py::class_<NaiveDipoleFlux, std::shared_ptr<NaiveDipoleFlux>, DipoleFluxAlgorithm> cls(mod,
101  "NaiveDipoleFlux");
102 
103  cls.def(py::init<NaiveDipoleFlux::Control const &, std::string const &, afw::table::Schema &>(), "ctrl"_a,
104  "name"_a, "schema"_a);
105 
106  cls.def("measure", &NaiveDipoleFlux::measure, "measRecord"_a, "exposure"_a);
107  cls.def("fail", &NaiveDipoleFlux::fail, "measRecord"_a, "error"_a = NULL);
108 }
109 
110 void declareNaiveDipoleCentroid(py::module &mod) {
111  py::class_<NaiveDipoleCentroid, std::shared_ptr<NaiveDipoleCentroid>, DipoleCentroidAlgorithm> cls(
112  mod, "NaiveDipoleCentroid");
113 
114  cls.def(py::init<NaiveDipoleCentroid::Control const &, std::string const &, afw::table::Schema &>(),
115  "ctrl"_a, "name"_a, "schema"_a);
116 
117  cls.def("getCenterKeys", &NaiveDipoleCentroid::getCenterKeys);
118  cls.def("getPositiveKeys", &NaiveDipoleCentroid::getPositiveKeys);
119  cls.def("getNegativeKeys", &NaiveDipoleCentroid::getNegativeKeys);
120 
121  cls.def("measure", &NaiveDipoleCentroid::measure, "measRecord"_a, "exposure"_a);
122  cls.def("mergeCentroids", &NaiveDipoleCentroid::mergeCentroids, "source"_a, "posValue"_a, "negValue"_a);
123  cls.def("fail", &NaiveDipoleCentroid::fail, "measRecord"_a, "error"_a = NULL);
124 }
125 
126 void declarePsfDipoleFlux(py::module &mod) {
127  py::class_<PsfDipoleFlux, std::shared_ptr<PsfDipoleFlux>, DipoleFluxAlgorithm> cls(mod, "PsfDipoleFlux");
128 
129  cls.def(py::init<PsfDipoleFlux::Control const &, std::string const &, afw::table::Schema &>(), "ctrl"_a,
130  "name"_a, "schema"_a);
131 
132  cls.def("chi2", &PsfDipoleFlux::chi2, "source"_a, "exposure"_a, "negCenterX"_a, "negCenterY"_a,
133  "negFlux"_a, "posCenterX"_a, "posCenterY"_a, "posFlux"_a);
134  cls.def("measure", &PsfDipoleFlux::measure, "measRecord"_a, "exposure"_a);
135  cls.def("fail", &PsfDipoleFlux::fail, "measRecord"_a, "error"_a = NULL);
136 }
137 
138 } // namespace lsst::ip::diffim::<anonymous>
139 
140 PYBIND11_MODULE(_dipoleAlgorithms, mod) {
141  py::module::import("lsst.afw.table");
142  py::module::import("lsst.meas.base");
143  py::module::import("lsst.pex.config");
144 
145  declareDipoleCentroidControl(mod);
146  declareDipoleFluxControl(mod);
147  declareDipolePsfFluxControl(mod);
148  declareDipoleCentroidAlgorithm(mod);
149  declareDipoleFluxAlgorithm(mod);
150  declareNaiveDipoleFlux(mod);
151  declareNaiveDipoleCentroid(mod);
152  declarePsfDipoleFlux(mod);
153 }
154 
155 } // diffim
156 } // ip
157 } // lsst
DipoleAlgorithms.h
lsst::ip::diffim::PYBIND11_MODULE
PYBIND11_MODULE(_dipoleAlgorithms, mod)
Definition: dipoleAlgorithms.cc:140
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
lsst::ip::diffim.DipoleFluxControl
DipoleFluxControl
Definition: __init__.py:50
Algorithm.h
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
lsst::ip::diffim.PsfDipoleFluxControl
PsfDipoleFluxControl
Definition: __init__.py:51
lsst::ip::isr.fringe.measure
def measure(mi, x, y, size, statistic, stats)
Definition: fringe.py:506
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42