Namespaces
	assembleImage

	camera

	cameraConfig

	cameraFactory

	cameraGeomEnumDicts

	cameraGeomLib

	detector

	detectorCollection

	fitsUtils

	makePixelToTanPixel

	pupil

	rotateBBoxBy90

	testUtils

	transformConfig

	utils

Classes
class	Camera
	A collection of Detectors plus additional coordinate system support. More...

class	CameraSys
	Camera coordinate system; used as a key in in TransformMap. More...

class	CameraSysPrefix
	Camera coordinate system prefix. More...

class	Detector
	Information about a CCD or other imaging detector. More...

class	DetectorCollection
	An immutable collection of Detectors that can be accessed by name or ID. More...

class	Orientation
	Describe a detector's orientation in the focal plane. More...

class	TransformMap
	A registry of 2-dimensional coordinate transforms for a specific camera. More...

Enumerations
enum	DetectorType { SCIENCE, FOCUS, GUIDER, WAVEFRONT }
	Type of imaging detector. More...

Functions
std::ostream &	operator<< (std::ostream &os, CameraSysPrefix const &detSysPrefix)

std::ostream &	operator<< (std::ostream &os, CameraSys const &cameraSys)

	PYBIND11_MODULE (camera, mod)

	PYBIND11_MODULE (cameraSys, mod)

template<typename SysT , typename PyClass >
void	declare1SysMethods (PyClass &cls)

template<typename FromSysT , typename ToSysT , typename PyClass >
void	declare2SysMethods (PyClass &cls)

	PYBIND11_MODULE (detector, mod)

	PYBIND11_MODULE (detectorCollection, mod)

	PYBIND11_MODULE (orientation, mod)

Variables
CameraSys const	FOCAL_PLANE = CameraSys("FocalPlane")
	Focal plane coordinates: Rectilinear x, y (and z when talking about the location of a detector) on the camera focal plane (mm). More...

CameraSys const	FIELD_ANGLE = CameraSys("FieldAngle")
	Field angle coordinates: Angular x,y offset from the optic axis (radians). More...

CameraSysPrefix const	PIXELS = CameraSysPrefix("Pixels")
	Nominal pixels on the detector (unbinned) This ignores manufacturing imperfections, "tree ring" distortions and all other such effects. More...

CameraSysPrefix const	TAN_PIXELS = CameraSysPrefix("TanPixels")
	Tangent-plane pixels on the detector (unbinned) More...

CameraSysPrefix const	ACTUAL_PIXELS = CameraSysPrefix("ActualPixels")
	The actual pixels where the photon lands and electrons are generated (unbinned) This takes into account manufacturing defects, "tree ring" distortions and other such effects. More...

string	NullLinearityType = "None"

Enumeration Type Documentation

◆ DetectorType

enum lsst::afw::cameraGeom::DetectorType

Type of imaging detector.

Enumerator
SCIENCE
FOCUS
GUIDER
WAVEFRONT

Definition at line 43 of file Detector.h.

                   {
     SCIENCE,
     FOCUS,
     GUIDER,
     WAVEFRONT,
 };

Function Documentation

◆ declare1SysMethods()

template<typename SysT , typename PyClass >

void lsst::afw::cameraGeom::declare1SysMethods ( PyClass & cls )

Definition at line 48 of file detector.cc.

                                       {
     cls.def("getCorners",
             (std::vector<lsst::geom::Point2D>(Detector::*)(SysT const &) const) & Detector::getCorners,
             "cameraSys"_a);
     cls.def("getCenter", (lsst::geom::Point2D(Detector::*)(SysT const &) const) & Detector::getCenter,
             "cameraSys"_a);
     cls.def("hasTransform", (bool (Detector::*)(SysT const &) const) & Detector::hasTransform, "cameraSys"_a);
     cls.def("makeCameraSys", (CameraSys const (Detector::*)(SysT const &) const) & Detector::makeCameraSys,
             "cameraSys"_a);
 }

◆ declare2SysMethods()

template<typename FromSysT , typename ToSysT , typename PyClass >

void lsst::afw::cameraGeom::declare2SysMethods ( PyClass & cls )

Definition at line 61 of file detector.cc.

                                       {
     cls.def("getTransform",
             (std::shared_ptr<geom::TransformPoint2ToPoint2>(Detector::*)(FromSysT const &, ToSysT const &)
                      const) &
                     Detector::getTransform,
             "fromSys"_a, "toSys"_a);
     cls.def("transform",
             (lsst::geom::Point2D(Detector::*)(lsst::geom::Point2D const &, FromSysT const &, ToSysT const &) const) &
                     Detector::transform,
             "point"_a, "fromSys"_a, "toSys"_a);
     cls.def("transform",
             (std::vector<lsst::geom::Point2D>(Detector::*)(std::vector<lsst::geom::Point2D> const &, FromSysT const &,
                                                      ToSysT const &) const) &
                     Detector::transform,
             "points"_a, "fromSys"_a, "toSys"_a);
 }

◆ operator<<() [1/2]

std::ostream & lsst::afw::cameraGeom::operator<<	(	std::ostream &	os,
		CameraSysPrefix const &	detSysPrefix
	)

Definition at line 47 of file CameraSys.cc.

                                                                             {
     os << "CameraSysPrefix(" << camSysPrefix.getSysName() << ")";
     return os;
 }

◆ operator<<() [2/2]

std::ostream & lsst::afw::cameraGeom::operator<<	(	std::ostream &	os,
		CameraSys const &	cameraSys
	)

Definition at line 52 of file CameraSys.cc.

                                                                    {
     os << "CameraSys(" << cameraSys.getSysName();
     if (cameraSys.hasDetectorName()) {
         os << ", " << cameraSys.getDetectorName();
     }
     os << ")";
     return os;
 }

◆ PYBIND11_MODULE() [1/5]

lsst::afw::cameraGeom::PYBIND11_MODULE	(	camera	,
		mod
	)

Definition at line 34 of file camera.cc.

                             {
     py::module::import("lsst.afw.cameraGeom.detectorCollection");
     py::module::import("lsst.afw.cameraGeom.transformMap");
 
     py::class_<Camera, DetectorCollection, std::shared_ptr<Camera>> cls(mod, "Camera");
 
     cls.def(py::init<std::string const &, Camera::DetectorList const &,
                      std::shared_ptr<TransformMap>, std::string const &>(),
             "name"_a, "detectorList"_a, "transformMap"_a, "pupilFactoryName"_a);
     // Python-only constructor that takes a PupilFactory type object for
     // backwards compatibility.
     cls.def(
         py::init(
             [](
                 std::string const & name,
                 Camera::DetectorList const & detectorList,
                 std::shared_ptr<TransformMap> transformMap,
                 py::object pupilFactoryClass
             ) {
                 std::string pupilFactoryName = "lsst.afw.cameraGeom.pupil.PupilFactory";
                 if (pupilFactoryClass != py::none()) {
                     pupilFactoryName = py::str("{}.{}").format(
                         pupilFactoryClass.attr("__module__"),
                         pupilFactoryClass.attr("__name__")
                     );
                 }
                 return std::make_shared<Camera>(name, detectorList, transformMap, pupilFactoryName);
             }
         ),
         "name"_a,
         "detectorList"_a,
         "transformMap"_a,
         "pupilFactoryClass"_a=py::none()
     );
     cls.def("getName", &Camera::getName);
     cls.def("getPupilFactoryName", &Camera::getPupilFactoryName);
     cls.def("findDetectors", &Camera::findDetectors, "point"_a, "cameraSys"_a);
     cls.def("findDetectorsList", &Camera::findDetectorsList, "pointList"_a, "cameraSys"_a);
     cls.def("getTransformMap", &Camera::getTransformMap);
     // transform methods are wrapped with lambdas that translate exceptions for backwards compatibility
     cls.def(
         "getTransform",
         [](Camera const & self, CameraSys const & fromSys, CameraSys const & toSys) {
             try {
                 return self.getTransform(fromSys, toSys);
             } catch (pex::exceptions::NotFoundError & err) {
                 PyErr_SetString(PyExc_KeyError, err.what());
                 throw py::error_already_set();
             }
         },
         "fromSys"_a, "toSys"_a
     );
     cls.def(
         "transform",
         [](
             Camera const & self,
             lsst::geom::Point2D const & point,
             CameraSys const & fromSys,
             CameraSys const & toSys
         ) {
             try {
                 return self.transform(point, fromSys, toSys);
             } catch (pex::exceptions::NotFoundError & err) {
                 PyErr_SetString(PyExc_KeyError, err.what());
                 throw py::error_already_set();
             }
         },
         "point"_a, "fromSys"_a, "toSys"_a
     );
     cls.def(
         "transform",
         [](
             Camera const & self,
             std::vector<lsst::geom::Point2D> const & points,
             CameraSys const & fromSys,
             CameraSys const & toSys
         ) {
             try {
                 return self.transform(points, fromSys, toSys);
             } catch (pex::exceptions::NotFoundError & err) {
                 PyErr_SetString(PyExc_KeyError, err.what());
                 throw py::error_already_set();
             }
         },
         "points"_a, "fromSys"_a, "toSys"_a
     );
 
     table::io::python::addPersistableMethods(cls);
 }

◆ PYBIND11_MODULE() [2/5]

lsst::afw::cameraGeom::PYBIND11_MODULE	(	detectorCollection	,
		mod
	)

Definition at line 35 of file detectorCollection.cc.

                                         {
     py::module::import("lsst.afw.cameraGeom.detector");
 
     py::class_<DetectorCollection, std::shared_ptr<DetectorCollection>> cls(mod, "DetectorCollection");
 
     cls.def(py::init<DetectorCollection::List const & >(), "list"_a);
     cls.def("getNameMap", &DetectorCollection::getNameMap);
     cls.def("getIdMap", &DetectorCollection::getIdMap);
     cls.def("getFpBBox", &DetectorCollection::getFpBBox);
     cls.def("__len__", &DetectorCollection::size);
     cls.def(
         "get",
         py::overload_cast<std::string const &, std::shared_ptr<Detector>>(
             &DetectorCollection::get, py::const_
         ),
         "name"_a, "default"_a=nullptr
     );
     cls.def(
         "get",
         py::overload_cast<int, std::shared_ptr<Detector>>(
             &DetectorCollection::get, py::const_
         ),
         "id"_a, "default"_a=nullptr
     );
     cls.def(
         "__contains__",
         [](DetectorCollection const & self, std::string const &name) {
             return self.get(name) != nullptr;
         }
     );
     cls.def(
         "__contains__",
         [](DetectorCollection const & self, int id) {
             return self.get(id) != nullptr;
         }
     );
 
     table::io::python::addPersistableMethods(cls);
 }

◆ PYBIND11_MODULE() [3/5]

lsst::afw::cameraGeom::PYBIND11_MODULE	(	orientation	,
		mod
	)

Definition at line 36 of file orientation.cc.

                                   {
     py::module::import("lsst.geom");
 
     /* Module level */
     py::class_<Orientation> cls(mod, "Orientation");
 
     /* Member types and enums */
 
     /* Constructors */
     cls.def(py::init<lsst::geom::Point2D, lsst::geom::Point2D, lsst::geom::Angle, lsst::geom::Angle, lsst::geom::Angle>(),
             "fpPosition"_a = lsst::geom::Point2D(0, 0), "refPoint"_a = lsst::geom::Point2D(-0.5, -0.5),
             "yaw"_a = lsst::geom::Angle(0), "pitch"_a = lsst::geom::Angle(0), "roll"_a = lsst::geom::Angle(0));
 
     /* Operators */
 
     /* Members */
     cls.def("getFpPosition", &Orientation::getFpPosition);
     cls.def("getReferencePoint", &Orientation::getReferencePoint);
     cls.def("getYaw", &Orientation::getYaw);
     cls.def("getPitch", &Orientation::getPitch);
     cls.def("getRoll", &Orientation::getRoll);
     cls.def("getNQuarter", &Orientation::getNQuarter);
     cls.def("makePixelFpTransform", &Orientation::makePixelFpTransform, "pixelSizeMm"_a);
     cls.def("makeFpPixelTransform", &Orientation::makeFpPixelTransform, "pixelSizeMm"_a);
     cls.def("getFpPosition", &Orientation::getFpPosition);
     cls.def("getFpPosition", &Orientation::getFpPosition);
     cls.def("getFpPosition", &Orientation::getFpPosition);
     cls.def("getFpPosition", &Orientation::getFpPosition);
 }

◆ PYBIND11_MODULE() [4/5]

lsst::afw::cameraGeom::PYBIND11_MODULE	(	cameraSys	,
		mod
	)

Definition at line 62 of file cameraSys.cc.

                                 {
     /* Module level */
     py::class_<CameraSysPrefix> clsCameraSysPrefix(mod, "CameraSysPrefix");
     py::class_<CameraSys> clsCameraSys(mod, "CameraSys");
 
     // The following must come after the associated pybind11 class is declared
     // (e.g. FOCAL_PLANE is a CameraSys, so clsCameraSys must have been declared
     mod.attr("FOCAL_PLANE") = py::cast(FOCAL_PLANE);
     mod.attr("FIELD_ANGLE") = py::cast(FIELD_ANGLE);
     mod.attr("PIXELS") = py::cast(PIXELS);
     mod.attr("TAN_PIXELS") = py::cast(TAN_PIXELS);
     mod.attr("ACTUAL_PIXELS") = py::cast(ACTUAL_PIXELS);
 
     /* Member types and enums */
     declareCommonSysMethods<CameraSysPrefix>(clsCameraSysPrefix);
     declareCommonSysMethods<CameraSys>(clsCameraSys);
 
     /* Constructors */
     clsCameraSysPrefix.def(py::init<std::string const &>(), "sysName"_a);
     clsCameraSys.def(py::init<std::string const &, std::string const &>(), "sysName"_a,
                      "detectorName"_a = "");
     clsCameraSys.def(py::init<CameraSysPrefix const &, std::string const &>(), "sysPrefix"_a,
                      "detectorName"_a = "");
 
     /* Operators */
 
     /* Members */
     clsCameraSys.def("getDetectorName", &CameraSys::getDetectorName);
     clsCameraSys.def("hasDetectorName", &CameraSys::hasDetectorName);
 }

◆ PYBIND11_MODULE() [5/5]

lsst::afw::cameraGeom::PYBIND11_MODULE	(	detector	,
		mod
	)

Definition at line 78 of file detector.cc.

                                {
     /* Module level */
     py::class_<Detector, std::shared_ptr<Detector>> cls(mod, "Detector");
 
     /* Member types and enums */
     py::enum_<DetectorType>(mod, "DetectorType")
             .value("SCIENCE", DetectorType::SCIENCE)
             .value("FOCUS", DetectorType::FOCUS)
             .value("GUIDER", DetectorType::GUIDER)
             .value("WAVEFRONT", DetectorType::WAVEFRONT)
             .export_values();
 
     /* Constructors */
     cls.def(py::init<std::string const &, int, DetectorType, std::string const &, lsst::geom::Box2I const &,
                      table::AmpInfoCatalog const &, Orientation const &, lsst::geom::Extent2D const &,
                      TransformMap::Transforms const &, Detector::CrosstalkMatrix const &>(),
             "name"_a, "id"_a, "type"_a, "serial"_a, "bbox"_a, "ampInfoCatalog"_a, "orientation"_a,
             "pixelSize"_a, "transforms"_a, "crosstalk"_a = Detector::CrosstalkMatrix());
     cls.def(py::init<std::string const &, int, DetectorType, std::string const &, lsst::geom::Box2I const &,
                      table::AmpInfoCatalog const &, Orientation const &, lsst::geom::Extent2D const &,
                      std::shared_ptr<TransformMap const>, Detector::CrosstalkMatrix const &>(),
             "name"_a, "id"_a, "type"_a, "serial"_a, "bbox"_a, "ampInfoCatalog"_a, "orientation"_a,
             "pixelSize"_a, "transformMap"_a, "crosstalk"_a = Detector::CrosstalkMatrix());
 
     /* Operators */
     cls.def("__getitem__",
             (std::shared_ptr<table::AmpInfoRecord const>(Detector::*)(int) const) & Detector::_get, "i"_a);
     cls.def("__getitem__",
             (std::shared_ptr<table::AmpInfoRecord const>(Detector::*)(std::string const &) const) &
                     Detector::_get,
             "name"_a);
     cls.def("__len__", &Detector::size);
 
     /* Members */
     cls.def("getName", &Detector::getName);
     cls.def("getId", &Detector::getId);
     cls.def("getType", &Detector::getType);
     cls.def("getSerial", &Detector::getSerial);
     cls.def("getBBox", &Detector::getBBox);
     cls.def("getAmpInfoCatalog", &Detector::getAmpInfoCatalog);
     cls.def("getOrientation", &Detector::getOrientation);
     cls.def("getPixelSize", &Detector::getPixelSize);
     cls.def("hasCrosstalk", &Detector::hasCrosstalk);
     cls.def("getCrosstalk", &Detector::getCrosstalk);
     cls.def("getTransformMap", &Detector::getTransformMap);
     cls.def("getNativeCoordSys", &Detector::getNativeCoordSys);
     declare1SysMethods<CameraSys>(cls);
     declare1SysMethods<CameraSysPrefix>(cls);
     declare2SysMethods<CameraSys, CameraSys>(cls);
     declare2SysMethods<CameraSys, CameraSysPrefix>(cls);
     declare2SysMethods<CameraSysPrefix, CameraSys>(cls);
     declare2SysMethods<CameraSysPrefix, CameraSysPrefix>(cls);
 
     table::io::python::addPersistableMethods(cls);
 }

Variable Documentation

◆ ACTUAL_PIXELS

CameraSysPrefix const lsst::afw::cameraGeom::ACTUAL_PIXELS = CameraSysPrefix("ActualPixels")

The actual pixels where the photon lands and electrons are generated (unbinned) This takes into account manufacturing defects, "tree ring" distortions and other such effects.

This is a detector prefix; call Detector.makeCameraSys(ACTUAL_PIXELS) to make a full coordsys.

Definition at line 38 of file CameraSys.cc.

◆ FIELD_ANGLE

CameraSys const lsst::afw::cameraGeom::FIELD_ANGLE = CameraSys("FieldAngle")

Field angle coordinates: Angular x,y offset from the optic axis (radians).

Definition at line 32 of file CameraSys.cc.

◆ FOCAL_PLANE

CameraSys const lsst::afw::cameraGeom::FOCAL_PLANE = CameraSys("FocalPlane")

Focal plane coordinates: Rectilinear x, y (and z when talking about the location of a detector) on the camera focal plane (mm).

For z=0 choose a convenient point near the focus at x, y = 0.

Definition at line 30 of file CameraSys.cc.

◆ NullLinearityType

string lsst.afw.cameraGeom.NullLinearityType = "None"

Definition at line 37 of file __init__.py.

◆ PIXELS

CameraSysPrefix const lsst::afw::cameraGeom::PIXELS = CameraSysPrefix("Pixels")

Nominal pixels on the detector (unbinned) This ignores manufacturing imperfections, "tree ring" distortions and all other such effects.

It is a uniform grid of rectangular (usually square) pixels.

This is a detector prefix; call Detector.makeCameraSys(PIXELS) to make a full coordsys.

Definition at line 34 of file CameraSys.cc.

◆ TAN_PIXELS

CameraSysPrefix const lsst::afw::cameraGeom::TAN_PIXELS = CameraSysPrefix("TanPixels")

Tangent-plane pixels on the detector (unbinned)

Converting from PIXELS to TAN_PIXELS has the effect of removing optical distortion (and the distortion due to rectangular pixels) with the point at the center of the detector being unaffected by the transformation.

In detail, PIXELS->TAN_PIXELS is PIXELS->FIELD_ANGLE plus an affine transformation, such that:

The x,y axes are parallel to the detector axes
The dimensions are nominal pixels at the center of the focal plane (where nominal pixels size is mean of x, y pixel size).
The point at the center of the detector has the same value in PIXELS and TAN_PIXELS

This is a detector prefix; call Detector.makeCameraSys(TAN_PIXELS) to make a full coordsys.

Definition at line 36 of file CameraSys.cc.

Namespaces

Classes

Enumerations

Functions

Variables