LSSTApplications  20.0.0
LSSTDataManagementBasePackage
amplifier.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 "ndarray/pybind11.h"
27 
30 
31 namespace py = pybind11;
32 using namespace pybind11::literals;
33 
34 namespace lsst {
35 namespace afw {
36 namespace cameraGeom {
37 namespace {
38 
39 using PyAmplifier = py::class_<Amplifier, std::shared_ptr<Amplifier>>;
40 using PyAmplifierBuilder = py::class_<Amplifier::Builder, Amplifier, std::shared_ptr<Amplifier::Builder>>;
41 
42 PyAmplifier declarePyAmplifier(py::module & mod) {
43  py::enum_<ReadoutCorner>(mod, "ReadoutCorner")
44  .value("LL", ReadoutCorner::LL)
45  .value("LR", ReadoutCorner::LR)
46  .value("UR", ReadoutCorner::UR)
47  .value("UL", ReadoutCorner::UL);
48  py::enum_<AssemblyState>(mod, "AssemblyState")
49  .value("RAW", AssemblyState::RAW)
50  .value("SCIENCE", AssemblyState::SCIENCE);
51  PyAmplifier cls(mod, "Amplifier");
52  cls.def_static("getRecordSchema", &Amplifier::getRecordSchema);
53  cls.def("toRecord", &Amplifier::toRecord);
54  cls.def("rebuild", &Amplifier::rebuild);
55  cls.def("getName", &Amplifier::getName);
56  cls.def("getBBox", &Amplifier::getBBox);
57  cls.def("getGain", &Amplifier::getGain);
58  cls.def("getReadNoise", &Amplifier::getReadNoise);
59  cls.def("getSaturation", &Amplifier::getSaturation);
60  cls.def("getSuspectLevel", &Amplifier::getSuspectLevel);
61  cls.def("getReadoutCorner", &Amplifier::getReadoutCorner);
62  cls.def("getLinearityCoeffs", &Amplifier::getLinearityCoeffs);
63  cls.def("getLinearityType", &Amplifier::getLinearityType);
64  cls.def("getLinearityThreshold", &Amplifier::getLinearityThreshold);
65  cls.def("getLinearityMaximum", &Amplifier::getLinearityMaximum);
66  cls.def("getLinearityUnits", &Amplifier::getLinearityUnits);
67  cls.def("getRawBBox", &Amplifier::getRawBBox);
68  cls.def("getRawDataBBox", &Amplifier::getRawDataBBox);
69  cls.def("getRawFlipX", &Amplifier::getRawFlipX);
70  cls.def("getRawFlipY", &Amplifier::getRawFlipY);
71  cls.def("getRawXYOffset", &Amplifier::getRawXYOffset);
72  cls.def("getRawHorizontalOverscanBBox", &Amplifier::getRawHorizontalOverscanBBox);
73  cls.def("getRawVerticalOverscanBBox", &Amplifier::getRawVerticalOverscanBBox);
74  cls.def("getRawPrescanBBox", &Amplifier::getRawPrescanBBox);
75  cls.def("getRawSerialOverscanBBox", &Amplifier::getRawSerialOverscanBBox);
76  cls.def("getRawParallelOverscanBBox", &Amplifier::getRawParallelOverscanBBox);
77  cls.def("getRawSerialPrescanBBox", &Amplifier::getRawSerialPrescanBBox);
78  cls.def("getRawHorizontalPrescanBBox", &Amplifier::getRawHorizontalPrescanBBox);
79  return cls;
80 }
81 
82 void declarePyAmplifierBuilder(PyAmplifier & parent) {
83  PyAmplifierBuilder cls(parent, "Builder");
84  cls.def_static("fromRecord", &Amplifier::Builder::fromRecord);
85  cls.def(py::init());
86  cls.def("finish", &Amplifier::Builder::finish);
87  cls.def("assign", [](Amplifier::Builder & self, Amplifier const & other) { self = other; });
88  cls.def("setName", &Amplifier::Builder::setName, "name"_a);
89  cls.def("setBBox", &Amplifier::Builder::setBBox, "bbox"_a);
90  cls.def("setGain", &Amplifier::Builder::setGain, "gain"_a);
91  cls.def("setReadNoise", &Amplifier::Builder::setReadNoise, "readNoise"_a);
92  cls.def("setSaturation", &Amplifier::Builder::setSaturation, "saturation"_a);
93  cls.def("setSuspectLevel", &Amplifier::Builder::setSuspectLevel, "suspectLevel"_a);
94  cls.def("setReadoutCorner", &Amplifier::Builder::setReadoutCorner, "corner"_a);
95  cls.def("setLinearityCoeffs", &Amplifier::Builder::setLinearityCoeffs, "coeffs"_a);
96  // Backwards compatibility: accept std::vector (list in Python) in
97  // addition to ndarray::Array (np.ndarray)
98  cls.def("setLinearityCoeffs",
99  [](Amplifier::Builder & self, std::vector<double> const & coeffs) {
100  ndarray::Array<double, 1, 1> array = ndarray::allocate(coeffs.size());
101  std::copy(coeffs.begin(), coeffs.end(), array.begin());
102  self.setLinearityCoeffs(array);
103  });
104  cls.def("setLinearityType", &Amplifier::Builder::setLinearityType, "type"_a);
105  cls.def("setLinearityThreshold", &Amplifier::Builder::setLinearityThreshold, "threshold"_a);
106  cls.def("setLinearityMaximum", &Amplifier::Builder::setLinearityMaximum, "maximum"_a);
107  cls.def("setLinearityUnits", &Amplifier::Builder::setLinearityUnits, "units"_a);
108  cls.def("setRawBBox", &Amplifier::Builder::setRawBBox, "bbox"_a);
109  cls.def("setRawDataBBox", &Amplifier::Builder::setRawDataBBox, "bbox"_a);
110  cls.def("setRawFlipX", &Amplifier::Builder::setRawFlipX, "rawFlipX"_a);
111  cls.def("setRawFlipY", &Amplifier::Builder::setRawFlipY, "rawFlipY"_a);
112  cls.def("setRawXYOffset", &Amplifier::Builder::setRawXYOffset, "offset"_a);
113  cls.def("setRawHorizontalOverscanBBox", &Amplifier::Builder::setRawHorizontalOverscanBBox, "bbox"_a);
114  cls.def("setRawVerticalOverscanBBox", &Amplifier::Builder::setRawVerticalOverscanBBox, "bbox"_a);
115  cls.def("setRawPrescanBBox", &Amplifier::Builder::setRawPrescanBBox, "bbox"_a);
116  cls.def("setRawSerialOverscanBBox", &Amplifier::Builder::setRawSerialOverscanBBox, "bbox"_a);
117  cls.def("setRawParallelOverscanBBox", &Amplifier::Builder::setRawParallelOverscanBBox, "bbox"_a);
118  cls.def("setRawSerialPrescanBBox", &Amplifier::Builder::setRawSerialPrescanBBox, "bbox"_a);
119  cls.def("setRawHorizontalPrescanBBox", &Amplifier::Builder::setRawHorizontalPrescanBBox, "bbox"_a);
120 }
121 
122 PYBIND11_MODULE(amplifier, mod) {
123  auto cls = declarePyAmplifier(mod);
124  declarePyAmplifierBuilder(cls);
125 }
126 
127 } // namespace
128 } // namespace cameraGeom
129 } // namespace afw
130 } // namespace lsst
std::vector< double >
std::vector::size
T size(T... args)
lsst::afw
Definition: imageAlgorithm.dox:1
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
BaseRecord.h
Amplifier.h
other
ItemVariant const * other
Definition: Schema.cc:56
std::copy
T copy(T... args)
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
std::vector::begin
T begin(T... args)
pybind11
Definition: _GenericMap.cc:40
std::vector::end
T end(T... args)
lsst::utils.tests.init
def init()
Definition: tests.py:58
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42
lsst::afw::cameraGeom::PYBIND11_MODULE
PYBIND11_MODULE(camera, mod)
Definition: camera.cc:133