Namespace lsst::afw::cameraGeom¶

namespace cameraGeom

Enums

enum ReadoutCorner

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

Values:

LL

LR

UR

UL

enum AssemblyState

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

Values:

RAW

SCIENCE

enum DetectorType

Type of imaging detector

Values:

SCIENCE

FOCUS

GUIDER

WAVEFRONT

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)

Variables

CameraSys const FOCAL_PLANE

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.

CameraSys const FIELD_ANGLE

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.

CameraSysPrefix const 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.

CameraSysPrefix const TAN_PIXELS

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.

CameraSysPrefix const ACTUAL_PIXELS

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.

class Amplifier

#include <Amplifier.h>

Geometry and electronic information about raw amplifier images

The Amplifier class itself is an abstract base class that provides no mutation or copy interfaces. Typically Amplifiers are constructed via the Builder subclass, which can produce a shared_ptr to an immutable Amplifier instance.

Here is a pictorial example showing the meaning of flipX and flipY:

    CCD with 4 amps        Desired assembled output      Use these parameters

    --x         x--            y
   |  amp1    amp2 |           |                               flipX       flipY
   y               y           |                       amp1    False       True
                               | CCD image             amp2    True        True
   y               y           |                       amp3    False       False
   |  amp3    amp4 |           |                       amp4    True        False
    --x         x--             ----------- x

Note

All bounding boxes are parent boxes with respect to the raw image.
The overscan and prescan bounding boxes represent the full regions; unusable regions are set via ISR configuration parameters.
xyOffset is not used for instrument signature removal (ISR); it is intended for use by display utilities. It supports construction of a raw CCD image in the case that raw data is provided as individual amplifier images (which is uncommon):
- Use 0,0 for cameras that supply raw data as a raw CCD image (most cameras)
- Use nonzero for cameras that supply raw data as separate amplifier images with xy0=0,0 (LSST)
This design assumes assembled X is always +/- raw X, which we require for CCDs (so that bleed trails are always along the Y axis).

Subclassed by lsst::afw::cameraGeom::Amplifier::Builder

class Camera : public lsst::afw::cameraGeom::DetectorCollection, public lsst::afw::table::io::PersistableFacade<Camera>

#include <Camera.h>

An immutable representation of a camera.

Cameras are created (and modified, when necessary) via the Camera::Builder helper class.

class CameraSys: #include <CameraSys.h>
Camera coordinate system; used as a key in in TransformMap

class CameraSysPrefix

#include <CameraSys.h>

Camera coordinate system prefix

Used for coordinate systems that are detector-based before the detector name is known (e.g. for constants such as PIXELS).

This is Jim Bosch’s clever idea for simplifying Detector.convert; CameraSys is always complete and CameraSysPrefix is not.

class Detector : public lsst::afw::cameraGeom::DetectorBase, public lsst::afw::table::io::PersistableFacade<Detector>, public Storable

#include <Detector.h>

A representation of a detector in a mosaic camera.

Detector holds both simple data fields (see DetectorBase) and a set of related coordinate systems and transforms, and acts as a container of Amplifier objects.

Detector is immutable, but copies can be modified via one of its Builder classes. A Detector must be created initially as part of a Camera (see Camera::Builder::add), but can then be modified either individually (see Detector::rebuild and Detector::PartialRebuilder) or as part of modifying the full Camera (see Detector::InCameraBuilder).

The coordinate systems and transforms known to a Detector are shared with its parent Camera and all other Detectors in that Camera.

class DetectorBase

#include <Detector.h>

An abstract base class that provides common accessors for Detector and Detector::Builder.

Subclassed by lsst::afw::cameraGeom::Detector, lsst::afw::cameraGeom::Detector::Builder

class DetectorCollection : public lsst::afw::cameraGeom::DetectorCollectionBase<Detector const>, public lsst::afw::table::io::PersistableFacade<DetectorCollection>, public lsst::afw::table::io::Persistable

#include <DetectorCollection.h>

An immutable collection of Detectors that can be accessed by name or ID

Subclassed by lsst::afw::cameraGeom::Camera

template<typename T> class DetectorCollectionBase

#include <DetectorCollection.h>

An abstract base class for collections of Detectors and specific subclasses thereof.

This class provides the common interface and implementation for

DetectorCollection (which holds true Detector instances) and Camera::Builder (which holds Detector::InCameraBuilder instances). It is not intended to define an interface independent of those classes.

Template Parameters

T: Element type; either Detector or a subclass thereof.

class Orientation

#include <Orientation.h>

Describe a detector’s orientation in the focal plane

All rotations are about the reference point on the detector. Rotations are intrinsic, meaning each rotation is applied in the coordinates system produced by the previous rotation. Rotations are applied in this order: yaw (Z), pitch (Y’), and roll (X’’).

Warning: : default refPoint is -0.5, -0.5 (the lower left corner of a detector). This means that the default-constructed Orientation is not a unity transform, but instead includes a 1/2 pixel shift.

class TransformMap : public lsst::afw::table::io::PersistableFacade<TransformMap>, public lsst::afw::table::io::Persistable

#include <TransformMap.h>

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

Represents the interrelationships between camera coordinate systems for a particular camera. It can be seen as a mapping between a pair of CameraSys and a Transform between them (though it does not conform to either the C++ map or Python dictionary APIs).

TransformMap supports:

Transforming between any two supported CameraSys using the transform methods.
Retrieving a transform between any two supported CameraSys using getTransform.
Iteration over supported CameraSys using begin and end in C++ and standard Python iteration in Python.

TransformMap is immutable and must always be held by shared_ptr; this is enforced by making all non-deleted constructors private, and instead providing static make member functions for construction (in Python, these are exposed as regular constructors).

Unless otherwise specified, all methods guarantee only basic exception safety.

Navigation

Namespace lsst::afw::cameraGeom¶