lsst.meas.base  14.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Groups Pages
flagHandler.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/utils/python.h"
30 
31 namespace py = pybind11;
32 using namespace pybind11::literals;
33 
34 namespace lsst {
35 namespace meas {
36 namespace base {
37 
38 namespace {
39 
40 void declareFlagDefinition(py::module &mod) {
41  py::class_<FlagDefinition, std::shared_ptr<FlagDefinition>> cls(mod, "FlagDefinition");
42 
43  cls.def(py::init<>());
44  cls.def(py::init<std::string, std::string, std::size_t>(), "name"_a, "doc"_a,
45  "number"_a = FlagDefinition::number_undefined);
46 
47  cls.def_readwrite("name", &FlagDefinition::name);
48  cls.def_readwrite("doc", &FlagDefinition::doc);
49  cls.def_readwrite("number", &FlagDefinition::number);
50 
51  cls.def("__eq__", &FlagDefinition::operator==, py::is_operator());
52  cls.def("__ne__", &FlagDefinition::operator!=, py::is_operator());
53 }
54 
55 void declareFlagDefinitionList(py::module &mod) {
56  py::class_<FlagDefinitionList, std::shared_ptr<FlagDefinitionList>> cls(mod, "FlagDefinitionList");
57 
58  cls.def(py::init<>());
59  cls.def(py::init<std::initializer_list<FlagDefinition> const &>());
60 
61  cls.def("__getitem__",
62  [](FlagDefinitionList const &self, int i) {
63  try {
64  auto cind = lsst::utils::python::cppIndex(self.size(), i);
65  return self[cind];
66  } catch (pex::exceptions::OutOfRangeError & err) {
67  // Python needs exception to be IndexError to generate __iter__; see DM-9715
68  PyErr_SetString(PyExc_IndexError, err.what());
69  throw py::error_already_set();
70  }
71  });
72  cls.def("__len__", &FlagDefinitionList::size);
73 
74  cls.def("getEmptyList", &FlagDefinitionList::getEmptyList);
75  cls.def("getDefinition",
76  (FlagDefinition(FlagDefinitionList::*)(std::size_t) const) & FlagDefinitionList::getDefinition,
77  "index"_a);
78  cls.def("getDefinition", (FlagDefinition(FlagDefinitionList::*)(std::string const &) const) &
79  FlagDefinitionList::getDefinition,
80  "name"_a);
81  cls.def("hasDefinition", &FlagDefinitionList::hasDefinition, "name"_a);
82  cls.def("addFailureFlag", &FlagDefinitionList::addFailureFlag, "doc"_a = "General Failure Flag");
83  cls.def("add", &FlagDefinitionList::add, "name"_a, "doc"_a);
84 }
85 
86 void declareFlagHandler(py::module &mod) {
87  py::class_<FlagHandler, std::shared_ptr<FlagHandler>> cls(mod, "FlagHandler");
88 
89  cls.def(py::init<>());
90  cls.def(py::init<afw::table::SubSchema const &, FlagDefinitionList const &, FlagDefinitionList const &>(),
91  "s"_a, "flagDefs"_a, "exclDefs"_a = FlagDefinitionList::getEmptyList());
92 
93  cls.def_static("getFailureFlagName", &FlagHandler::getFailureFlagName);
94  cls.def_static("addFields", &FlagHandler::addFields, "schema"_a, "prefix"_a, "flagDefs"_a,
95  "exclDefs"_a=FlagDefinitionList::getEmptyList());
96 
97  cls.def("getFlagNumber", &FlagHandler::getFlagNumber, "flagName"_a);
98  cls.def("getFlagName", &FlagHandler::getFlagName, "i"_a);
99  cls.def("getValue", (bool (FlagHandler::*)(afw::table::BaseRecord const &, std::size_t) const) &
100  FlagHandler::getValue,
101  "record"_a, "i"_a);
102  cls.def("getValue", (bool (FlagHandler::*)(afw::table::BaseRecord const &, std::string const &) const) &
103  FlagHandler::getValue,
104  "record"_a, "flagName"_a);
105  cls.def("setValue", (void (FlagHandler::*)(afw::table::BaseRecord &, std::size_t, bool) const) &
106  FlagHandler::setValue,
107  "record"_a, "i"_a, "value"_a);
108  cls.def("setValue", (void (FlagHandler::*)(afw::table::BaseRecord &, std::string const &, bool) const) &
109  FlagHandler::setValue,
110  "record"_a, "flagName"_a, "value"_a);
111  cls.def("getFailureFlagNumber", &FlagHandler::getFailureFlagNumber);
112  cls.def("handleFailure", &FlagHandler::handleFailure, "record"_a, "error"_a = nullptr);
113 }
114 
115 } // <anonymous>
116 
117 PYBIND11_PLUGIN(flagHandler) {
118  py::module::import("lsst.afw.table");
119 
120  py::module mod("flagHandler");
121 
122  declareFlagDefinition(mod);
123  declareFlagDefinitionList(mod);
124  declareFlagHandler(mod);
125 
126  return mod.ptr();
127 }
128 
129 } // base
130 } // meas
131 } // lsst
PYBIND11_PLUGIN(algorithm)
Definition: algorithm.cc:37