LSST Applications 27.0.0,g0265f82a02+469cd937ee,g02d81e74bb+21ad69e7e1,g1470d8bcf6+cbe83ee85a,g2079a07aa2+e67c6346a6,g212a7c68fe+04a9158687,g2305ad1205+94392ce272,g295015adf3+81dd352a9d,g2bbee38e9b+469cd937ee,g337abbeb29+469cd937ee,g3939d97d7f+72a9f7b576,g487adcacf7+71499e7cba,g50ff169b8f+5929b3527e,g52b1c1532d+a6fc98d2e7,g591dd9f2cf+df404f777f,g5a732f18d5+be83d3ecdb,g64a986408d+21ad69e7e1,g858d7b2824+21ad69e7e1,g8a8a8dda67+a6fc98d2e7,g99cad8db69+f62e5b0af5,g9ddcbc5298+d4bad12328,ga1e77700b3+9c366c4306,ga8c6da7877+71e4819109,gb0e22166c9+25ba2f69a1,gb6a65358fc+469cd937ee,gbb8dafda3b+69d3c0e320,gc07e1c2157+a98bf949bb,gc120e1dc64+615ec43309,gc28159a63d+469cd937ee,gcf0d15dbbd+72a9f7b576,gdaeeff99f8+a38ce5ea23,ge6526c86ff+3a7c1ac5f1,ge79ae78c31+469cd937ee,gee10cc3b42+a6fc98d2e7,gf1cff7945b+21ad69e7e1,gfbcc870c63+9a11dc8c8f
LSST Data Management Base Package
Loading...
Searching...
No Matches
_kernel.cc
Go to the documentation of this file.
1/*
2 * LSST Data Management System
3 * Copyright 2008-2016 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 <lsst/utils/python.h>
25
26#include <pybind11/stl.h>
27
29#include "lsst/afw/table/io/python.h" // for addPersistableMethods
30
31namespace py = pybind11;
32
33using namespace py::literals;
34
35using namespace lsst::afw::math;
36namespace lsst {
37namespace afw {
38namespace math {
39void wrapKernel(lsst::utils::python::WrapperCollection &wrappers) {
40 using PyKernel = py::class_<Kernel, std::shared_ptr<Kernel>>;
41
42 wrappers.addSignatureDependency("lsst.afw.table");
43 wrappers.addSignatureDependency("lsst.afw.table.io");
44
45 wrappers.wrapType(PyKernel(wrappers.module, "Kernel"), [](auto &mod, auto &cls) {
46 lsst::afw::table::io::python::addPersistableMethods<Kernel>(cls);
47
48 cls.def("clone", &Kernel::clone);
49 cls.def("resized", &Kernel::resized, "width"_a, "height"_a);
50 cls.def("computeImage", &Kernel::computeImage, "image"_a, "doNormalize"_a, "x"_a = 0.0, "y"_a = 0.0);
51 cls.def("getDimensions", &Kernel::getDimensions);
52 cls.def("setDimensions", &Kernel::setDimensions);
53 cls.def("setWidth", &Kernel::setWidth);
54 cls.def("setHeight", &Kernel::setHeight);
55 cls.def("getWidth", &Kernel::getWidth);
56 cls.def("getHeight", &Kernel::getHeight);
57 cls.def("getCtr", &Kernel::getCtr);
58 cls.def("getBBox", &Kernel::getBBox);
59 cls.def("getNKernelParameters", &Kernel::getNKernelParameters);
60 cls.def("getNSpatialParameters", &Kernel::getNSpatialParameters);
61 cls.def("getSpatialFunction", &Kernel::getSpatialFunction);
62 cls.def("getSpatialFunctionList", &Kernel::getSpatialFunctionList);
63 cls.def("getKernelParameter", &Kernel::getKernelParameter);
64 cls.def("getKernelParameters", &Kernel::getKernelParameters);
65 cls.def("growBBox", &Kernel::growBBox);
66 cls.def("shrinkBBox", &Kernel::shrinkBBox);
67 cls.def("setCtr", &Kernel::setCtr);
68 cls.def("getSpatialParameters", &Kernel::getSpatialParameters);
69 cls.def("isSpatiallyVarying", &Kernel::isSpatiallyVarying);
70 cls.def("setKernelParameters",
71 (void (Kernel::*)(std::vector<double> const &)) & Kernel::setKernelParameters);
72 cls.def("setKernelParameters",
73 (void (Kernel::*)(std::pair<double, double> const &)) & Kernel::setKernelParameters);
74 cls.def("setSpatialParameters", &Kernel::setSpatialParameters);
75 cls.def("computeKernelParametersFromSpatialModel", &Kernel::computeKernelParametersFromSpatialModel);
76 cls.def("toString", &Kernel::toString, "prefix"_a = "");
77 cls.def("computeCache", &Kernel::computeCache);
78 cls.def("getCacheSize", &Kernel::getCacheSize);
79 });
80
81 using PyFixedKernel = py::class_<FixedKernel, std::shared_ptr<FixedKernel>, Kernel>;
82 wrappers.wrapType(PyFixedKernel(wrappers.module, "FixedKernel"), [](auto &mod, auto &cls) {
83 cls.def(py::init<>());
84 cls.def(py::init<lsst::afw::image::Image<Kernel::Pixel> const &>(), "image"_a);
85 cls.def(py::init<lsst::afw::math::Kernel const &, lsst::geom::Point2D const &>(), "kernel"_a,
86 "pos"_a);
87 cls.def("clone", &FixedKernel::clone);
88 cls.def("resized", &FixedKernel::resized, "width"_a, "height"_a);
89 cls.def("toString", &FixedKernel::toString, "prefix"_a = "");
90 cls.def("getSum", &FixedKernel::getSum);
91 cls.def("isPersistable", &FixedKernel::isPersistable);
92 });
93
94 using PyAnalyticKernel = py::class_<AnalyticKernel, std::shared_ptr<AnalyticKernel>, Kernel>;
95 wrappers.wrapType(PyAnalyticKernel(wrappers.module, "AnalyticKernel"), [](auto &mod, auto &cls) {
96 cls.def(py::init<>());
97 // Workaround for NullSpatialFunction and py::arg not playing well with Citizen (TODO: no longer
98 // needed?)
99 cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &>(), "width"_a, "height"_a,
100 "kernelFunction"_a);
101 cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &, Kernel::SpatialFunction const &>(),
102 "width"_a, "height"_a, "kernelFunction"_a, "spatialFunction"_a);
103 cls.def(py::init<int, int, AnalyticKernel::KernelFunction const &,
104 std::vector<Kernel::SpatialFunctionPtr> const &>(),
105 "width"_a, "height"_a, "kernelFunction"_a, "spatialFunctionList"_a);
106 cls.def("clone", &AnalyticKernel::clone);
107 cls.def("resized", &AnalyticKernel::resized, "width"_a, "height"_a);
108 cls.def("computeImage", &AnalyticKernel::computeImage, "image"_a, "doNormalize"_a, "x"_a = 0.0,
109 "y"_a = 0.0);
110 cls.def("getKernelParameters", &AnalyticKernel::getKernelParameters);
111 cls.def("getKernelFunction", &AnalyticKernel::getKernelFunction);
112 cls.def("toString", &AnalyticKernel::toString, "prefix"_a = "");
113 cls.def("isPersistable", &AnalyticKernel::isPersistable);
114 });
115
116 using PyDeltaFunctionKernel =
117 py::class_<DeltaFunctionKernel, std::shared_ptr<DeltaFunctionKernel>, Kernel>;
118 wrappers.wrapType(
119 PyDeltaFunctionKernel(wrappers.module, "DeltaFunctionKernel"), [](auto &mod, auto &cls) {
120 cls.def(py::init<int, int, lsst::geom::Point2I const &>(), "width"_a, "height"_a, "point"_a);
121 cls.def("clone", &DeltaFunctionKernel::clone);
122 cls.def("resized", &DeltaFunctionKernel::resized, "width"_a, "height"_a);
123 cls.def("getPixel", &DeltaFunctionKernel::getPixel);
124 cls.def("toString", &DeltaFunctionKernel::toString, "prefix"_a = "");
125 cls.def("isPersistable", &DeltaFunctionKernel::isPersistable);
126 });
127
128 using PyLinearCombinationKernel =
129 py::class_<LinearCombinationKernel, std::shared_ptr<LinearCombinationKernel>, Kernel>;
130 wrappers.wrapType(
131 PyLinearCombinationKernel(wrappers.module, "LinearCombinationKernel"), [](auto &mod, auto &cls) {
132 cls.def(py::init<>());
133 cls.def(py::init<KernelList const &, std::vector<double> const &>(), "kernelList"_a,
134 "kernelParameters"_a);
135 cls.def(py::init<KernelList const &, Kernel::SpatialFunction const &>(), "kernelList"_a,
136 "spatialFunction"_a);
137 cls.def(py::init<KernelList const &, std::vector<Kernel::SpatialFunctionPtr> const &>(),
138 "kernelList"_a, "spatialFunctionList"_a);
139 cls.def("clone", &LinearCombinationKernel::clone);
140 cls.def("resized", &LinearCombinationKernel::resized, "width"_a, "height"_a);
141 cls.def("getKernelParameters", &LinearCombinationKernel::getKernelParameters);
142 cls.def("getKernelList", &LinearCombinationKernel::getKernelList);
143 cls.def("getKernelSumList", &LinearCombinationKernel::getKernelSumList);
144 cls.def("getNBasisKernels", &LinearCombinationKernel::getNBasisKernels);
145 cls.def("checkKernelList", &LinearCombinationKernel::checkKernelList);
146 cls.def("isDeltaFunctionBasis", &LinearCombinationKernel::isDeltaFunctionBasis);
147 cls.def("refactor", &LinearCombinationKernel::refactor);
148 cls.def("toString", &LinearCombinationKernel::toString, "prefix"_a = "");
149 cls.def("isPersistable", &LinearCombinationKernel::isPersistable);
150 });
151
152 using PySeparableKernel = py::class_<SeparableKernel, std::shared_ptr<SeparableKernel>, Kernel>;
153 wrappers.wrapType(PySeparableKernel(wrappers.module, "SeparableKernel"), [](auto &mod, auto &cls) {
154 cls.def(py::init<>());
155 // Workaround for NullSpatialFunction and py::arg not playing well with Citizen (TODO: no longer
156 // needed?)
157 cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
158 SeparableKernel::KernelFunction const &>(),
159 "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a);
160 cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
161 SeparableKernel::KernelFunction const &, Kernel::SpatialFunction const &>(),
162 "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a, "spatialFunction"_a);
163 cls.def(py::init<int, int, SeparableKernel::KernelFunction const &,
164 SeparableKernel::KernelFunction const &,
165 std::vector<Kernel::SpatialFunctionPtr> const &>(),
166 "width"_a, "height"_a, "kernelColFunction"_a, "kernelRowFunction"_a, "spatialFunctionList"_a);
167 cls.def("clone", &SeparableKernel::clone);
168 cls.def("resized", &SeparableKernel::resized, "width"_a, "height"_a);
169 cls.def("computeVectors", &SeparableKernel::computeVectors);
170 cls.def("getKernelParameter", &SeparableKernel::getKernelParameter);
171 cls.def("getKernelParameters", &SeparableKernel::getKernelParameters);
172 cls.def("getKernelColFunction", &SeparableKernel::getKernelColFunction);
173 cls.def("getKernelRowFunction", &SeparableKernel::getKernelRowFunction);
174 cls.def("toString", &SeparableKernel::toString, "prefix"_a = "");
175 cls.def("computeCache", &SeparableKernel::computeCache);
176 cls.def("getCacheSize", &SeparableKernel::getCacheSize);
177 });
178}
179} // namespace math
180} // namespace afw
181} // namespace lsst
Kernels are used for convolution with MaskedImages and (eventually) Images.
Definition Kernel.h:110
void wrapKernel(lsst::utils::python::WrapperCollection &wrappers)
Definition _kernel.cc:39