lsst::afw::cameraGeom Namespace Reference

Namespaces
	amplifier
	assembleImage
	camera
	cameraConfig
	cameraFactory
	cameraGeomEnumDicts
	cameraGeomLib
	detector
	detectorCollection
	makePixelToTanPixel
	pupil
	rotateBBoxBy90
	testUtils
	transformConfig
	utils

Classes
class	Amplifier
	Geometry and electronic information about raw amplifier images. More...
class	Camera
	An immutable representation of a camera. More...
class	CameraSys
	Camera coordinate system; used as a key in in TransformMap. More...
class	CameraSysPrefix
	Camera coordinate system prefix. More...
class	Detector
	A representation of a detector in a mosaic camera. More...
class	DetectorBase
	An abstract base class that provides common accessors for Detector and Detector::Builder. More...
class	DetectorCollection
	An immutable collection of Detectors that can be accessed by name or ID. More...
class	DetectorCollectionBase
	An abstract base class for collections of Detectors and specific subclasses thereof. 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...

Typedefs
using	PyCamera = py::class_< Camera, DetectorCollection, std::shared_ptr< Camera > >
using	PyCameraBuilder = py::class_< Camera::Builder, DetectorCollectionBase< Detector::InCameraBuilder >, std::shared_ptr< Camera::Builder > >

Enumerations
enum	ReadoutCorner { ReadoutCorner::LL, ReadoutCorner::LR, ReadoutCorner::UR, ReadoutCorner::UL }
	Readout corner, in the frame of reference of the assembled image. More...
enum	AssemblyState { AssemblyState::RAW, AssemblyState::SCIENCE }
	Assembly state of the amplifier, used to identify bounding boxes and component existence. More...
enum	DetectorType { DetectorType::SCIENCE, DetectorType::FOCUS, DetectorType::GUIDER, DetectorType::WAVEFRONT }
	Type of imaging detector. More...

Functions
void	swap (CameraSys &a, CameraSys &b)
std::ostream &	operator<< (std::ostream &os, CameraSysPrefix const &detSysPrefix)
std::ostream &	operator<< (std::ostream &os, CameraSys const &cameraSys)
std::ostream &	operator<< (std::ostream &os, TransformMap::Connection const &connection)
void	declareCameraBuilder (PyCamera &parent)
void	declareCamera (py::module &mod)
	PYBIND11_MODULE (camera, mod)
	PYBIND11_MODULE (cameraSys, mod)
	PYBIND11_MODULE (orientation, mod)

Variables
CameraSys const	FOCAL_PLANE = CameraSys("FocalPlane")
	Focal plane coordinates: Position on a 2-d planar approximation to the focal plane (x,y mm). More...
CameraSys const	FIELD_ANGLE = CameraSys("FieldAngle")
	Field angle coordinates: Angle of a principal ray relative to the optical axis (x,y radians). More...
CameraSysPrefix const	PIXELS = CameraSysPrefix("Pixels")
	Pixel coordinates: Nominal position on the entry surface of a given detector (x, y unbinned pixels). More...
CameraSysPrefix const	TAN_PIXELS = CameraSysPrefix("TanPixels")
	Tangent-plane pixels on the detector (x, y unbinned pixels) More...
CameraSysPrefix const	ACTUAL_PIXELS = CameraSysPrefix("ActualPixels")
	The actual pixels where the photon lands and electrons are generated (x,y unbinned) This takes into account manufacturing defects, "tree ring" distortions and other such effects. More...
string	NullLinearityType = "None"

Typedef Documentation

PyCamera

using lsst::afw::cameraGeom::PyCamera = typedef py::class_<Camera, DetectorCollection, std::shared_ptr<Camera> >

Definition at line 36 of file camera.cc.

PyCameraBuilder

using lsst::afw::cameraGeom::PyCameraBuilder = typedef py::class_<Camera::Builder, DetectorCollectionBase<Detector::InCameraBuilder>, std::shared_ptr<Camera::Builder> >

Definition at line 38 of file camera.cc.

Enumeration Type Documentation

AssemblyState

enum lsst::afw::cameraGeom::AssemblyState

strong

Assembly state of the amplifier, used to identify bounding boxes and component existence.

Enumerator
RAW
SCIENCE

Definition at line 48 of file Amplifier.h.

                         {
    RAW,
    SCIENCE,
};

DetectorType

enum lsst::afw::cameraGeom::DetectorType

strong

Type of imaging detector.

Enumerator
SCIENCE
FOCUS
GUIDER
WAVEFRONT

Definition at line 44 of file Detector.h.

                        {
    SCIENCE,
    FOCUS,
    GUIDER,
    WAVEFRONT,
};

ReadoutCorner

enum lsst::afw::cameraGeom::ReadoutCorner

strong

Readout corner, in the frame of reference of the assembled image.

Enumerator
LL
LR
UR
UL

Definition at line 38 of file Amplifier.h.

                         {
    LL,
    LR,
    UR,
    UL,
};

Function Documentation

declareCamera()

void lsst::afw::cameraGeom::declareCamera

(

py::module &

mod

)

Definition at line 46 of file camera.cc.

                                   {
    PyCamera cls(mod, "Camera");
    declareCameraBuilder(cls);
    cls.def("rebuild", &Camera::rebuild);
    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);
    // 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("getTransformMap", &Camera::getTransformMap);
    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);
}

declareCameraBuilder()

void lsst::afw::cameraGeom::declareCameraBuilder

(

PyCamera &

parent

)

Definition at line 105 of file camera.cc.

                                             {
    PyCameraBuilder cls(parent, "Builder");
    cls.def(py::init<std::string const &>(), "name"_a);
    cls.def(py::init<Camera const &>(), "camera"_a);
    cls.def("finish", &Camera::Builder::finish);
    cls.def("getName", &Camera::Builder::getName);
    cls.def("setName", &Camera::Builder::setName);
    cls.def("getPupilFactoryName", &Camera::Builder::getPupilFactoryName);
    cls.def("setPupilFactoryName", &Camera::Builder::setPupilFactoryName);
    cls.def("setPupilFactoryClass",
            [](Camera::Builder & self, py::object pupilFactoryClass) {
                std::string pupilFactoryName = "lsst.afw.cameraGeom.pupil.PupilFactory";
                if (!pupilFactoryClass.is(py::none())) {
                    pupilFactoryName = py::str("{}.{}").format(
                        pupilFactoryClass.attr("__module__"),
                        pupilFactoryClass.attr("__name__")
                    );
                }
                self.setPupilFactoryName(pupilFactoryName);
            });
    cls.def("setTransformFromFocalPlaneTo", &Camera::Builder::setTransformFromFocalPlaneTo,
            "toSys"_a, "transform"_a);
    cls.def("discardTransformFromFocalPlaneTo",&Camera::Builder::discardTransformFromFocalPlaneTo);
    cls.def("add", &Camera::Builder::add);
    cls.def("__delitem__", py::overload_cast<int>(&Camera::Builder::remove));
    cls.def("__delitem__", py::overload_cast<std::string const &>(&Camera::Builder::remove));
}

operator<<() [1/3]

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/3]

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;
}

operator<<() [3/3]

std::ostream & lsst::afw::cameraGeom::operator<<	(	std::ostream &	os,
		TransformMap::Connection const &	connection
	)

Definition at line 170 of file TransformMap.cc.

                                                                                    {
    return os << connection.fromSys << "->" << connection.toSys;
}

PYBIND11_MODULE() [1/3]

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() [2/3]

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() [3/3]

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

Definition at line 133 of file camera.cc.

                            {
    py::module::import("lsst.afw.cameraGeom.detectorCollection");
    py::module::import("lsst.afw.cameraGeom.detector");
    py::module::import("lsst.afw.cameraGeom.transformMap");

    declareCamera(mod);
}

swap()

void lsst::afw::cameraGeom::swap ( CameraSys &  a, CameraSys &  b  )

inline

Definition at line 157 of file CameraSys.h.

                                               {
    a.swap(b);
}

Variable Documentation

ACTUAL_PIXELS

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

The actual pixels where the photon lands and electrons are generated (x,y 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 CameraSys.

Definition at line 38 of file CameraSys.cc.

FIELD_ANGLE

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

Field angle coordinates: Angle of a principal ray relative to the optical axis (x,y radians).

The orientation of the x,y axes is the same as FOCAL_PLANE.

Definition at line 32 of file CameraSys.cc.

FOCAL_PLANE

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

Focal plane coordinates: Position on a 2-d planar approximation to the focal plane (x,y mm).

The origin and orientation may be defined by the camera team, but we strongly recommend that the origin be on the optical axis and (if using CCD detectors) that the X axis be aligned along CCD rows.

Note

Location and orientation of detectors are defined in a 3-d version of FOCAL_PLANE coordinates (the z axis is also relevant). 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")

Pixel coordinates: Nominal position on the entry surface of a given detector (x, y unbinned pixels).

For CCD detectors the x axis must be along rows (the direction of the serial register). This is required for our interpolation algorithm to interpolate across bad columns.

This ignores manufacturing imperfections, "tree ring" distortions and all other such effects. It is a uniform grid of rectangular (usually square) pixels.

Warning

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

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 (x, y unbinned pixels)

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 CameraSys.

Definition at line 36 of file CameraSys.cc.