LSSTApplications  20.0.0
LSSTDataManagementBasePackage
photometryTransform.cc
Go to the documentation of this file.
1 // -*- LSST-C++ -*-
2 /*
3  * This file is part of jointcal.
4  *
5  * Developed for the LSST Data Management System.
6  * This product includes software developed by the LSST Project
7  * (https://www.lsst.org).
8  * See the COPYRIGHT file at the top-level directory of this distribution
9  * for details of code ownership.
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <https://www.gnu.org/licenses/>.
23  */
24 
25 #include "pybind11/pybind11.h"
26 #include "pybind11/eigen.h"
27 #include "ndarray/pybind11.h"
28 #include "ndarray/eigen.h"
29 #include "Eigen/Core"
30 
31 #include "lsst/utils/python.h"
32 
34 
35 namespace py = pybind11;
36 using namespace pybind11::literals;
37 
38 namespace lsst {
39 namespace jointcal {
40 namespace {
41 
42 void declarePhotometryTransform(py::module &mod) {
43  py::class_<PhotometryTransform, std::shared_ptr<PhotometryTransform>> cls(mod, "PhotometryTransform");
44 
45  cls.def("transform",
46  (double (PhotometryTransform::*)(double, double, double) const) & PhotometryTransform::transform,
47  "x"_a, "y"_a, "value"_a);
48  cls.def("transformError",
49  (double (PhotometryTransform::*)(double, double, double, double) const) &
50  PhotometryTransform::transformError,
51  "x"_a, "y"_a, "value"_a, "valueErr"_a);
52  cls.def("offsetParams", &PhotometryTransform::offsetParams);
53  cls.def("clone", &PhotometryTransform::clone);
54  cls.def("getNpar", &PhotometryTransform::getNpar);
55  cls.def("getParameters", &PhotometryTransform::getParameters);
56  cls.def("computeParameterDerivatives",
57  [](PhotometryTransform const &self, double x, double y, double instFlux) {
58  Eigen::VectorXd derivatives(self.getNpar());
59  self.computeParameterDerivatives(x, y, instFlux, derivatives);
60  return derivatives;
61  });
62 
63  utils::python::addOutputOp(cls, "__str__");
64  utils::python::addOutputOp(cls, "__repr__");
65 }
66 
67 void declarePhotometryTransformSpatiallyInvariant(py::module &mod) {
68  py::class_<PhotometryTransformSpatiallyInvariant, std::shared_ptr<PhotometryTransformSpatiallyInvariant>,
69  PhotometryTransform>
70  cls(mod, "PhotometryTransformSpatiallyInvariant");
71 }
72 
73 void declareFluxTransformSpatiallyInvariant(py::module &mod) {
74  py::class_<FluxTransformSpatiallyInvariant, std::shared_ptr<FluxTransformSpatiallyInvariant>,
75  PhotometryTransformSpatiallyInvariant, PhotometryTransform>
76  cls(mod, "FluxTransformSpatiallyInvariant");
77 
78  cls.def(py::init<double>(), "value"_a = 1);
79 }
80 
81 void declareMagnitudeTransformSpatiallyInvariant(py::module &mod) {
82  py::class_<MagnitudeTransformSpatiallyInvariant, std::shared_ptr<MagnitudeTransformSpatiallyInvariant>,
83  PhotometryTransformSpatiallyInvariant, PhotometryTransform>
84  cls(mod, "MagnitudeTransformSpatiallyInvariant");
85 
86  cls.def(py::init<double>(), "value"_a = 0);
87 }
88 
89 void declarePhotometryTransformChebyshev(py::module &mod) {
90  py::class_<PhotometryTransformChebyshev, std::shared_ptr<PhotometryTransformChebyshev>,
91  PhotometryTransform>
92  cls(mod, "PhotometryTransformChebyshev");
93 
94  cls.def("getCoefficients", &PhotometryTransformChebyshev::getCoefficients);
95  cls.def("getOrder", &PhotometryTransformChebyshev::getOrder);
96  cls.def("getBBox", &PhotometryTransformChebyshev::getBBox);
97  cls.def("integrate", py::overload_cast<>(&PhotometryTransformChebyshev::integrate, py::const_));
98  cls.def("integrate",
99  py::overload_cast<geom::Box2D const &>(&PhotometryTransformChebyshev::integrate, py::const_),
100  "box"_a);
101 }
102 
103 void declareFluxTransformChebyshev(py::module &mod) {
104  py::class_<FluxTransformChebyshev, std::shared_ptr<FluxTransformChebyshev>, PhotometryTransformChebyshev>
105  cls(mod, "FluxTransformChebyshev");
106 
107  cls.def(py::init<size_t, geom::Box2D const &>(), "order"_a, "bbox"_a);
108  cls.def(py::init<ndarray::Array<double, 2, 2> const &, geom::Box2D const &>(), "coefficients"_a,
109  "bbox"_a);
110 }
111 
112 void declareMagnitudeTransformChebyshev(py::module &mod) {
113  py::class_<MagnitudeTransformChebyshev, std::shared_ptr<MagnitudeTransformChebyshev>,
114  PhotometryTransformChebyshev>
115  cls(mod, "MagnitudeTransformChebyshev");
116 
117  cls.def(py::init<size_t, geom::Box2D const &>(), "order"_a, "bbox"_a);
118  cls.def(py::init<ndarray::Array<double, 2, 2> const &, geom::Box2D const &>(), "coefficients"_a,
119  "bbox"_a);
120 }
121 
122 PYBIND11_MODULE(photometryTransform, mod) {
123  declarePhotometryTransform(mod);
124 
125  declarePhotometryTransformSpatiallyInvariant(mod);
126  declareFluxTransformSpatiallyInvariant(mod);
127  declareMagnitudeTransformSpatiallyInvariant(mod);
128  declarePhotometryTransformChebyshev(mod);
129  declareFluxTransformChebyshev(mod);
130  declareMagnitudeTransformChebyshev(mod);
131 }
132 
133 } // namespace
134 } // namespace jointcal
135 } // namespace lsst
y
int y
Definition: SpanSet.cc:49
lsst::utils::python::addOutputOp
void addOutputOp(PyClass &cls, std::string const &method)
Add __str__ or __repr__ method implemented by operator<<.
Definition: python.h:87
PhotometryTransform.h
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
x
double x
Definition: ChebyshevBoundedField.cc:277
lsst::jointcal
Definition: Associations.h:49
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
python.h
lsst::afw::math::integrate
UnaryFunctionT::result_type integrate(UnaryFunctionT func, typename UnaryFunctionT::argument_type const a, typename UnaryFunctionT::argument_type const b, double eps=1.0e-6)
The 1D integrator.
Definition: Integrate.h:886
transform
table::Key< int > transform
Definition: TransformMap.cc:299
pybind11
Definition: _GenericMap.cc:40
lsst::geom::Box2D
A floating-point coordinate rectangle geometry.
Definition: Box.h:413
lsst::utils.tests.init
def init()
Definition: tests.py:58
lsst::afw::image.slicing.clone
clone
Definition: slicing.py:257
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42
lsst::afw::cameraGeom::PYBIND11_MODULE
PYBIND11_MODULE(camera, mod)
Definition: camera.cc:133