lsst::afw::image Namespace Reference

Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects. More...

Namespaces
	_exposureFitsReaderContinued
	_exposureInfoContinued
	_exposureSummaryStats
	_filter
	apCorrMap
	basicUtils
	detail
	details
	exposure
	image
	impl
	maskedImage
	pixel
	python
	SdssFilters
	testUtils
	utils

Classes
class	imageIterator
	An ImageBase iterator. More...
class	imageLocator
	An ImageBase locator. More...
class	ApCorrMap
	A thin wrapper around std::map to allow aperture corrections to be attached to Exposures. More...
class	CoaddInputs
	A simple Persistable struct containing ExposureCatalogs that record the inputs to a coadd. More...
class	Color
	Describe the colour of a source. More...
class	DefectBase
	Encapsulate information about a bad portion of a detector. More...
class	Exposure
	A class to contain the data, WCS, and other information needed to describe an image of the sky. More...
class	ExposureFitsReader
	A FITS reader class for Exposures and their components. More...
class	ExposureInfo
	A collection of all the things that make an Exposure different from a MaskedImage. More...
class	FilterLabel
	A group of labels for a filter in an exposure or coadd. More...
class	Image
	A class to represent a 2-dimensional array of pixels. More...
class	DecoratedImage
	A container for an Image and its associated metadata. More...
struct	pixelOp0
	A functor class equivalent to std::function<ValT ()>, but with a virtual operator() More...
struct	pixelOp1
	A functor class equivalent to std::function<ValT (ValT)>, but with a virtual operator() More...
struct	pixelOp1XY
	A functor class equivalent to std::function<ValT (int, int, ValT)>, but with a virtual operator() More...
struct	pixelOp2
	A functor class equivalent to std::function<LhsT (LhsT, RhsT)>, but with a virtual operator() More...
struct	pixelOp2XY
	A functor class equivalent to std::function<LhsT (int, int, LhsT, RhsT)>, but with a virtual operator() More...
class	CheckIndices
	A class used to request that array accesses be checked. More...
struct	Reference
	metafunction to extract reference type from PixelT More...
struct	ConstReference
	metafunction to extract const reference type from PixelT More...
class	ImageBase
	The base class for all image classed (Image, Mask, MaskedImage, ...) More...
class	ImageBaseFitsReader
	Base class for image FITS readers. More...
class	ImageFitsReader
	A FITS reader class for regular Images. More...
class	ImagePca
class	ImageSlice
	A class to specify a slice of an image. More...
class	Mask
	Represent a 2-dimensional array of bitmask pixels. More...
class	MaskedImage
	A class to manipulate images, masks, and variance as a single object. More...
struct	GetImage
class	MaskedImageFitsReader
	A FITS reader class for MaskedImages and their components. More...
class	MaskFitsReader
	A FITS reader class for Masks. More...
struct	Measurement
	A value and its error. More...
class	PhotoCalib
	The photometric calibration of an exposure. More...
class	TransmissionCurve
	A spatially-varying transmission curve as a function of wavelength. More...
class	VisitInfo
	Information about a single exposure of an imaging camera. More...

Typedefs
typedef std::int32_t	MaskPixel
	default type for Masks and MaskedImage Masks More...
typedef float	VariancePixel
	default type for MaskedImage variance images More...
using	PyCoaddInputs = py::class_< CoaddInputs, std::shared_ptr< CoaddInputs >, typehandling::Storable >
using	PyColor = py::class_< Color, std::shared_ptr< Color > >
using	PyTransmissionCurve = py::class_< TransmissionCurve, std::shared_ptr< TransmissionCurve >, typehandling::Storable >

Enumerations
enum	ImageOrigin { PARENT , LOCAL }
enum	xOrY { X , Y }
enum class	RotType { UNKNOWN , SKY , HORIZON , MOUNT }
	Type of rotation. More...

Functions
double	abMagFromFlux (double flux)
	Compute AB magnitude from flux in Janskys. More...
double	abMagErrFromFluxErr (double fluxErr, double flux)
	Compute AB magnitude error from flux and flux error in Janskys. More...
double	fluxFromABMag (double mag) noexcept
	Compute flux in Janskys from AB magnitude. More...
double	fluxErrFromABMagErr (double magErr, double mag) noexcept
	Compute flux error in Janskys from AB magnitude error and AB magnitude. More...
template<typename T >
ndarray::Array< T, 1 >	abMagFromFlux (ndarray::Array< T const, 1 > const &flux)
	Compute AB magnitude from flux in Janskys. More...
template<typename T >
ndarray::Array< T, 1 >	abMagErrFromFluxErr (ndarray::Array< T const, 1 > const &fluxErr, ndarray::Array< T const, 1 > const &flux)
	Compute AB magnitude error from flux and flux error in Janskys. More...
template<typename T >
ndarray::Array< T, 1 >	fluxFromABMag (ndarray::Array< T const, 1 > const &mag)
	Compute flux in Janskys from AB magnitude. More...
template<typename T >
ndarray::Array< T, 1 >	fluxErrFromABMagErr (ndarray::Array< T const, 1 > const &magErr, ndarray::Array< T const, 1 > const &mag)
	Compute flux error in Janskys from AB magnitude error and AB magnitude. More...
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
std::shared_ptr< Exposure< ImagePixelT, MaskPixelT, VariancePixelT > >	makeExposure (MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &mimage, std::shared_ptr< geom::SkyWcs const > wcs=std::shared_ptr< geom::SkyWcs const >())
	A function to return an Exposure of the correct type (cf. More...
	FilterProperty (FilterProperty const &)=default
	FilterProperty (FilterProperty &&) noexcept=default
FilterProperty &	operator= (FilterProperty const &)=default
FilterProperty &	operator= (FilterProperty &&) noexcept=default
	~FilterProperty () noexcept=default
std::string const &	getName () const noexcept
	Return a filter's name. More...
double	getLambdaEff () const noexcept
	Return the filter's effective wavelength (nm) More...
double	getLambdaMin () const noexcept
	Return the filter's minimum wavelength (nm) where the transmission is above 1% of the maximum. More...
double	getLambdaMax () const noexcept
	Return the filter's maximum wavelength (nm) where the transmission is above 1% of the maximum. More...
bool	operator== (FilterProperty const &rhs) const noexcept
	Return true iff two FilterProperties are identical. More...
bool	operator!= (FilterProperty const &rhs) const noexcept
	Return true iff rhs != this. More...
std::size_t	hash_value () const noexcept
	Return a hash of this object. More...
std::string	getPersistenceName () const override
std::string	getPythonModule () const override
void	write (OutputArchiveHandle &handle) const override
std::string	getDatabaseFilterLabel (std::string const &filterLabel)
	Remap special characters, etc. More...
template<typename LhsPixelT , typename RhsPixelT >
Image< LhsPixelT > &	operator+= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
	Add lhs to Image rhs (i.e. pixel-by-pixel addition) where types are different. More...
template<typename LhsPixelT , typename RhsPixelT >
Image< LhsPixelT > &	operator-= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
	Subtract lhs from Image rhs (i.e. pixel-by-pixel subtraction) where types are different. More...
template<typename LhsPixelT , typename RhsPixelT >
Image< LhsPixelT > &	operator*= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
	Multiply lhs by Image rhs (i.e. pixel-by-pixel multiplication) where types are different. More...
template<typename LhsPixelT , typename RhsPixelT >
Image< LhsPixelT > &	operator/= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
	Divide lhs by Image rhs (i.e. pixel-by-pixel division) where types are different. More...
template<typename PixelT >
void	swap (Image< PixelT > &a, Image< PixelT > &b)
template<typename PixelT >
void	swap (DecoratedImage< PixelT > &a, DecoratedImage< PixelT > &b)
lsst::geom::Box2I	bboxFromMetadata (daf::base::PropertySet &metadata)
	Determine the image bounding box from its metadata (FITS header) More...
template<typename T1 , typename T2 >
bool	imagesOverlap (ImageBase< T1 > const &image1, ImageBase< T2 > const &image2)
	Return true if the pixels for two images or masks overlap in memory. More...
template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
	Set each pixel in an Image<LhsT> to func() More...
template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp1< LhsT > const &func)
	Set each pixel in an Image<LhsT> to func(lhs) More...
template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp1XY< LhsT > const &func)
	Set each pixel in an Image<LhsT> to func(x, y, lhs) More...
template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp1< RhsT > const &func)
	Set each pixel in an Image<LhsT> to func(rhs), getting the rhs from an Image<RhsT> More...
template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2< LhsT, RhsT > const &func)
	Set each pixel in an Image<LhsT> to func(lhs, rhs), getting the rhs from an Image<RhsT> More...
template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2XY< LhsT, RhsT > const &func)
	Set each pixel in an Image<LhsT> to func(x, y, lhs, rhs), getting the rhs from an Image<RhsT> More...
template<typename PixelT >
void	swap (ImageBase< PixelT > &a, ImageBase< PixelT > &b)
template<typename Image1T , typename Image2T >
double	innerProduct (Image1T const &lhs, Image2T const &rhs, int const border=0)
	Calculate the inner product of two images. More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator+ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
	Overload operator+() More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator+ (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
	Overload operator+() More...
template<typename PixelT >
void	operator+= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator+=() More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator- (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
	Overload operator-() More...
template<typename PixelT >
void	operator-= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator-=() More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator* (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
	Overload operator*() More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator* (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
	Overload operator*() More...
template<typename PixelT >
void	operator*= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator*=() More...
template<typename PixelT >
std::shared_ptr< Image< PixelT > >	operator/ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
	Overload operator/() More...
template<typename PixelT >
void	operator/= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator/=() More...
double	indexToPosition (double ind)
	Convert image index to image position. More...
int	positionToIndex (double pos)
	Convert image position to nearest integer index. More...
int	positionToIndex (double &residual, double pos)
	Convert image position to index (nearest integer and fractional parts) More...
std::pair< int, double >	positionToIndex (double const pos, bool)
	Convert image position to index (nearest integer and fractional parts) More...
template<typename PixelT >
void	swap (Mask< PixelT > &a, Mask< PixelT > &b)
template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > *	makeMaskedImage (typename std::shared_ptr< Image< ImagePixelT >> image, typename std::shared_ptr< Mask< MaskPixelT >> mask=Mask< MaskPixelT >(), typename std::shared_ptr< Image< VariancePixelT >> variance=Image< VariancePixelT >())
	A function to return a MaskedImage of the correct type (cf. More...
template<typename ImagePixelT1 , typename ImagePixelT2 >
bool	imagesOverlap (MaskedImage< ImagePixelT1, MaskPixel, VariancePixel > const &image1, MaskedImage< ImagePixelT2, MaskPixel, VariancePixel > const &image2)
	Return true if the pixels for two masked images (image, variance or mask plane) overlap in memory. More...
std::ostream &	operator<< (std::ostream &os, Measurement const &measurement)
void	assertNonNegative (double value, std::string const &name)
	Raise lsst::pex::exceptions::InvalidParameterError if value is not >=0. More...
std::shared_ptr< PhotoCalib >	makePhotoCalibFromMetadata (daf::base::PropertySet &metadata, bool strip=false)
	Construct a PhotoCalib from FITS FLUXMAG0/FLUXMAG0ERR keywords. More...
std::shared_ptr< PhotoCalib >	makePhotoCalibFromCalibZeroPoint (double instFluxMag0, double instFluxMag0Err)
	Construct a PhotoCalib from the deprecated Calib-style instFluxMag0/instFluxMag0Err values. More...
template<typename ImageT >
ImageT::SinglePixel	badPixel (typename ImageT::Pixel bad=0)
	Return a value indicating a bad pixel for the given Image type. More...
std::ostream &	operator<< (std::ostream &os, VisitInfo const &visitInfo)
void	wrapCalib (lsst::utils::python::WrapperCollection &wrappers)
void	wrapCoaddInputs (lsst::utils::python::WrapperCollection &wrappers)
void	wrapColor (lsst::utils::python::WrapperCollection &wrappers)
void	wrapDefect (lsst::utils::python::WrapperCollection &wrappers)
void	wrapExposureInfo (lsst::utils::python::WrapperCollection &wrappers)
void	wrapFilter (lsst::utils::python::WrapperCollection &wrappers)
void	wrapFilterLabel (lsst::utils::python::WrapperCollection &wrappers)
void	wrapExposure (lsst::utils::python::WrapperCollection &)
void	wrapImagePca (lsst::utils::python::WrapperCollection &)
void	wrapImageUtils (lsst::utils::python::WrapperCollection &)
void	wrapPhotoCalib (lsst::utils::python::WrapperCollection &)
void	wrapReaders (lsst::utils::python::WrapperCollection &)
void	wrapTransmissionCurve (lsst::utils::python::WrapperCollection &)
void	wrapVisitInfo (lsst::utils::python::WrapperCollection &)
	PYBIND11_MODULE (_imageLib, mod)
void	declareVisitInfo (lsst::utils::python::WrapperCollection &wrappers)
void	declareRotType (lsst::utils::python::WrapperCollection &wrappers)
	PYBIND11_MODULE (_exposure, mod)
void	wrapImage (lsst::utils::python::WrapperCollection &wrappers)
void	wrapImageSlice (lsst::utils::python::WrapperCollection &)
	PYBIND11_MODULE (_maskedImage, mod)
template ndarray::Array< float, 1 >	abMagFromFlux (ndarray::Array< float const, 1 > const &flux)
template ndarray::Array< float, 1 >	abMagErrFromFluxErr (ndarray::Array< float const, 1 > const &fluxErr, ndarray::Array< float const, 1 > const &flux)
template ndarray::Array< float, 1 >	fluxFromABMag (ndarray::Array< float const, 1 > const &mag)
template ndarray::Array< float, 1 >	fluxErrFromABMagErr (ndarray::Array< float const, 1 > const &magErr, ndarray::Array< float const, 1 > const &mag)
template ndarray::Array< double, 1 >	abMagFromFlux (ndarray::Array< double const, 1 > const &flux)
template ndarray::Array< double, 1 >	abMagErrFromFluxErr (ndarray::Array< double const, 1 > const &fluxErr, ndarray::Array< double const, 1 > const &flux)
template ndarray::Array< double, 1 >	fluxFromABMag (ndarray::Array< double const, 1 > const &mag)
template ndarray::Array< double, 1 >	fluxErrFromABMagErr (ndarray::Array< double const, 1 > const &magErr, ndarray::Array< double const, 1 > const &mag)
std::shared_ptr< FilterLabel >	makeFilterLabelDirect (std::string const &name)
	Convert an old-style filter name to a FilterLabel without external information. More...
std::shared_ptr< FilterLabel >	makeFilterLabel (Filter const &filter)
	Convert an old-style Filter to a FilterLabel. More...
std::shared_ptr< FilterLabel >	makeFilterLabel (std::string const &name)
	Convert an old-style single Filter name to a FilterLabel, using available information. More...
Filter	makeFilter (FilterLabel const &label)
	Convert a FilterLabel back to an old-style Filter. More...
template bool	imagesOverlap< std::uint16_t, std::uint16_t > (MaskedImage< std::uint16_t > const &, MaskedImage< std::uint16_t > const &)
template bool	imagesOverlap< std::uint16_t, int > (MaskedImage< std::uint16_t > const &, MaskedImage< int > const &)
template bool	imagesOverlap< std::uint16_t, float > (MaskedImage< std::uint16_t > const &, MaskedImage< float > const &)
template bool	imagesOverlap< std::uint16_t, double > (MaskedImage< std::uint16_t > const &, MaskedImage< double > const &)
template bool	imagesOverlap< std::uint16_t, std::uint64_t > (MaskedImage< std::uint16_t > const &, MaskedImage< std::uint64_t > const &)
template bool	imagesOverlap< int, std::uint16_t > (MaskedImage< int > const &, MaskedImage< std::uint16_t > const &)
template bool	imagesOverlap< int, int > (MaskedImage< int > const &, MaskedImage< int > const &)
template bool	imagesOverlap< int, float > (MaskedImage< int > const &, MaskedImage< float > const &)
template bool	imagesOverlap< int, double > (MaskedImage< int > const &, MaskedImage< double > const &)
template bool	imagesOverlap< int, std::uint64_t > (MaskedImage< int > const &, MaskedImage< std::uint64_t > const &)
template bool	imagesOverlap< float, std::uint16_t > (MaskedImage< float > const &, MaskedImage< std::uint16_t > const &)
template bool	imagesOverlap< float, int > (MaskedImage< float > const &, MaskedImage< int > const &)
template bool	imagesOverlap< float, float > (MaskedImage< float > const &, MaskedImage< float > const &)
template bool	imagesOverlap< float, double > (MaskedImage< float > const &, MaskedImage< double > const &)
template bool	imagesOverlap< float, std::uint64_t > (MaskedImage< float > const &, MaskedImage< std::uint64_t > const &)
template bool	imagesOverlap< double, std::uint16_t > (MaskedImage< double > const &, MaskedImage< std::uint16_t > const &)
template bool	imagesOverlap< double, int > (MaskedImage< double > const &, MaskedImage< int > const &)
template bool	imagesOverlap< double, float > (MaskedImage< double > const &, MaskedImage< float > const &)
template bool	imagesOverlap< double, double > (MaskedImage< double > const &, MaskedImage< double > const &)
template bool	imagesOverlap< double, std::uint64_t > (MaskedImage< double > const &, MaskedImage< std::uint64_t > const &)
template bool	imagesOverlap< std::uint64_t, std::uint16_t > (MaskedImage< std::uint64_t > const &, MaskedImage< std::uint16_t > const &)
template bool	imagesOverlap< std::uint64_t, int > (MaskedImage< std::uint64_t > const &, MaskedImage< int > const &)
template bool	imagesOverlap< std::uint64_t, float > (MaskedImage< std::uint64_t > const &, MaskedImage< float > const &)
template bool	imagesOverlap< std::uint64_t, double > (MaskedImage< std::uint64_t > const &, MaskedImage< double > const &)
template bool	imagesOverlap< std::uint64_t, std::uint64_t > (MaskedImage< std::uint64_t > const &, MaskedImage< std::uint64_t > const &)
std::ostream &	operator<< (std::ostream &os, PhotoCalib const &photoCalib)

Variables
class[[deprecated("Removed with no replacement (but see lsst::afw::image::TransmissionCurve). Will be " "removed after v22.")]] FilterProperty	final
	Describe the properties of a Filter (e.g. More...
const double	PixelZeroPos = 0.0
	position of center of pixel 0 More...

Detailed Description

Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.

Typedef Documentation

MaskPixel

typedef std::int32_t lsst::afw::image::MaskPixel

default type for Masks and MaskedImage Masks

Definition at line 34 of file LsstImageTypes.h.

PyCoaddInputs

using lsst::afw::image::PyCoaddInputs = typedef py::class_<CoaddInputs, std::shared_ptr<CoaddInputs>, typehandling::Storable>

Definition at line 40 of file _coaddInputs.cc.

PyColor

using lsst::afw::image::PyColor = typedef py::class_<Color, std::shared_ptr<Color> >

Definition at line 38 of file _color.cc.

PyTransmissionCurve

using lsst::afw::image::PyTransmissionCurve = typedef py::class_<TransmissionCurve, std::shared_ptr<TransmissionCurve>, typehandling::Storable>

Definition at line 43 of file _transmissionCurve.cc.

VariancePixel

typedef float lsst::afw::image::VariancePixel

default type for MaskedImage variance images

Definition at line 35 of file LsstImageTypes.h.

Enumeration Type Documentation

ImageOrigin

enum lsst::afw::image::ImageOrigin

Enumerator
PARENT
LOCAL

Definition at line 94 of file ImageBase.h.

{ PARENT, LOCAL };

RotType

enum lsst::afw::image::RotType

strong

Type of rotation.

Enumerator
UNKNOWN	Rotation angle is unknown. Note: if there is no instrument rotator then it is better to compute SKY or HORIZON and use that rotation type rather than specify UNKNOWN.
SKY	Position angle of focal plane +Y, measured from N through E. At 0 degrees, +Y is along N and +X is along E/W depending on handedness. At 90 degrees, +Y is along E and +X is along S/N depending on handedness.
HORIZON	Position angle of focal plane +Y, measured from +Alt through +Az. At 0 degrees, +Y is along +Alt and +X is along +/-Az, depending on handedness. At 90 degrees, +Y is along +Az and +X is along -/+Alt, depending on handedness.
MOUNT	The position sent to the instrument rotator; the details depend on the rotator.

Definition at line 45 of file VisitInfo.h.

                   {
    UNKNOWN,  
    SKY,      
    HORIZON,  
    MOUNT     
};

xOrY

enum lsst::afw::image::xOrY

Enumerator
X
Y

Definition at line 36 of file ImageUtils.h.

{ X, Y };

Function Documentation

~FilterProperty()

lsst::afw::image::~FilterProperty ( )

defaultnoexcept

abMagErrFromFluxErr() [1/4]

double lsst::afw::image::abMagErrFromFluxErr ( double  fluxErr, double  flux  )

inline

Compute AB magnitude error from flux and flux error in Janskys.

Definition at line 52 of file Calib.h.

                                                               {
    return std::abs(fluxErr / (-0.4 * flux * std::log(10)));
}

abMagErrFromFluxErr() [2/4]

template ndarray::Array< double , 1> lsst::afw::image::abMagErrFromFluxErr	(	ndarray::Array< double const, 1 > const &	fluxErr,
		ndarray::Array< double const, 1 > const &	flux
	)

abMagErrFromFluxErr() [3/4]

template ndarray::Array< float , 1> lsst::afw::image::abMagErrFromFluxErr	(	ndarray::Array< float const, 1 > const &	fluxErr,
		ndarray::Array< float const, 1 > const &	flux
	)

abMagErrFromFluxErr() [4/4]

template<typename T >

ndarray::Array< T, 1 > lsst::afw::image::abMagErrFromFluxErr	(	ndarray::Array< T const, 1 > const &	fluxErr,
		ndarray::Array< T const, 1 > const &	flux
	)

Compute AB magnitude error from flux and flux error in Janskys.

Definition at line 52 of file Calib.cc.

                                                                               {
    if (flux.getNumElements() != fluxErr.getNumElements()) {
        throw LSST_EXCEPT(pex::exceptions::LengthError, (boost::format("Length mismatch: %d vs %d") %
                                                         flux.getNumElements() % fluxErr.getNumElements())
                                                                .str());
    }
    ndarray::Array<T, 1> out = ndarray::allocate(flux.getShape());
    for (std::size_t ii = 0; ii < flux.getNumElements(); ++ii) {
        out[ii] = abMagErrFromFluxErr(fluxErr[ii], flux[ii]);
    }
    return out;
}

abMagFromFlux() [1/4]

double lsst::afw::image::abMagFromFlux ( double  flux )

inline

Compute AB magnitude from flux in Janskys.

Definition at line 49 of file Calib.h.

{ return -2.5 * std::log10(flux / JanskysPerABFlux); }

abMagFromFlux() [2/4]

template ndarray::Array< double , 1> lsst::afw::image::abMagFromFlux

(

ndarray::Array< double const, 1 > const &

flux

)

abMagFromFlux() [3/4]

template ndarray::Array< float , 1> lsst::afw::image::abMagFromFlux

(

ndarray::Array< float const, 1 > const &

flux

)

abMagFromFlux() [4/4]

template<typename T >

ndarray::Array< T, 1 > lsst::afw::image::abMagFromFlux

(

ndarray::Array< T const, 1 > const &

flux

)

Compute AB magnitude from flux in Janskys.

Definition at line 42 of file Calib.cc.

                                                                       {
    ndarray::Array<T, 1> out = ndarray::allocate(flux.getShape());
    for (std::size_t ii = 0; ii < flux.getNumElements(); ++ii) {
        out[ii] = abMagFromFlux(flux[ii]);
    }
    return out;
}

assertNonNegative()

void lsst::afw::image::assertNonNegative ( double  value, std::string const &  name  )

inline

Raise lsst::pex::exceptions::InvalidParameterError if value is not >=0.

Used for checking the calibration mean/error in the constructor.

Parameters

value	Value that should be positive.
name	Text to prepend to error message.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if value < 0

Definition at line 69 of file PhotoCalib.h.

                                                                   {
    if (value < 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          (boost::format("%s must be positive: %.3g") % name % value).str());
    }
}

badPixel()

template<typename ImageT >

ImageT::SinglePixel badPixel

(

typename ImageT::Pixel

bad = 0

)

Return a value indicating a bad pixel for the given Image type.

A quiet NaN is returned for types that support it otherwise bad

Parameters

bad	The bad value if NaN isn't supported

Definition at line 60 of file Utils.h.

  {
    typedef typename ImageT::SinglePixel SinglePixelT;
    return SinglePixelT(std::numeric_limits<SinglePixelT>::has_quiet_NaN
                                ? std::numeric_limits<SinglePixelT>::quiet_NaN()
                                : bad);
}

bboxFromMetadata()

lsst::geom::Box2I lsst::afw::image::bboxFromMetadata

(

daf::base::PropertySet &

metadata

)

Determine the image bounding box from its metadata (FITS header)

Note that this modifies the metadata, stripping the WCS headers that provide the xy0.

Definition at line 694 of file Image.cc.

                                                             {
    lsst::geom::Extent2I dims;
    if (metadata.exists("ZNAXIS1") && metadata.exists("ZNAXIS2")) {
        dims = lsst::geom::Extent2I(metadata.getAsInt("ZNAXIS1"), metadata.getAsInt("ZNAXIS2"));
    } else {
        dims = lsst::geom::Extent2I(metadata.getAsInt("NAXIS1"), metadata.getAsInt("NAXIS2"));
    }
    lsst::geom::Point2I xy0 = geom::getImageXY0FromMetadata(metadata, detail::wcsNameForXY0);
    return lsst::geom::Box2I(xy0, dims);
}

declareRotType()

void lsst::afw::image::declareRotType

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 112 of file _visitInfo.cc.

                                                                {
    wrappers.wrapType(py::enum_<RotType>(wrappers.module, "RotType"), [](auto &mod, auto &enm) {
        enm.value("UNKNOWN", RotType::UNKNOWN);
        enm.value("SKY", RotType::SKY);
        enm.value("HORIZON", RotType::HORIZON);
        enm.value("MOUNT", RotType::MOUNT);
        enm.export_values();
    });
}

declareVisitInfo()

void lsst::afw::image::declareVisitInfo

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 57 of file _visitInfo.cc.

                                                                  {
    wrappers.wrapType(
            py::class_<VisitInfo, std::shared_ptr<VisitInfo>, typehandling::Storable>(wrappers.module,
                                                                                      "VisitInfo"),
            [](auto &mod, auto &cls) {
                /* Constructors */
                cls.def(py::init<table::RecordId, double, double, daf::base::DateTime const &, double,
                                 lsst::geom::Angle const &, lsst::geom::SpherePoint const &,
                                 lsst::geom::SpherePoint const &, double, lsst::geom::Angle const &,
                                 RotType const &, coord::Observatory const &, coord::Weather const &,
                                 std::string const &>(),
                        "exposureId"_a = 0, "exposureTime"_a = nan, "darkTime"_a = nan,
                        "date"_a = daf::base::DateTime(), "ut1"_a = nan, "era"_a = nanAngle,
                        "boresightRaDec"_a = lsst::geom::SpherePoint(nanAngle, nanAngle),
                        "boresightAzAlt"_a = lsst::geom::SpherePoint(nanAngle, nanAngle),
                        "boresightAirmass"_a = nan, "boresightRotAngle"_a = nanAngle,
                        "rotType"_a = RotType::UNKNOWN,
                        "observatory"_a = coord::Observatory(nanAngle, nanAngle, nan),
                        "weather"_a = coord::Weather(nan, nan, nan), "instrumentLabel"_a = "");
                cls.def(py::init<daf::base::PropertySet const &>(), "metadata"_a);
                cls.def(py::init<VisitInfo const &>(), "visitInfo"_a);
 
                table::io::python::addPersistableMethods<VisitInfo>(cls);
 
                /* Operators */
                cls.def(
                        "__eq__", [](VisitInfo const &self, VisitInfo const &other) { return self == other; },
                        py::is_operator());
                cls.def(
                        "__ne__", [](VisitInfo const &self, VisitInfo const &other) { return self != other; },
                        py::is_operator());
 
                /* Members */
                cls.def("getExposureId", &VisitInfo::getExposureId);
                cls.def("getExposureTime", &VisitInfo::getExposureTime);
                cls.def("getDarkTime", &VisitInfo::getDarkTime);
                cls.def("getDate", &VisitInfo::getDate);
                cls.def("getUt1", &VisitInfo::getUt1);
                cls.def("getEra", &VisitInfo::getEra);
                cls.def("getBoresightRaDec", &VisitInfo::getBoresightRaDec);
                cls.def("getBoresightAzAlt", &VisitInfo::getBoresightAzAlt);
                cls.def("getBoresightAirmass", &VisitInfo::getBoresightAirmass);
                cls.def("getBoresightParAngle", &VisitInfo::getBoresightParAngle);
                cls.def("getBoresightRotAngle", &VisitInfo::getBoresightRotAngle);
                cls.def("getRotType", &VisitInfo::getRotType);
                cls.def("getObservatory", &VisitInfo::getObservatory);
                cls.def("getWeather", &VisitInfo::getWeather);
                cls.def("isPersistable", &VisitInfo::isPersistable);
                cls.def("getLocalEra", &VisitInfo::getLocalEra);
                cls.def("getBoresightHourAngle", &VisitInfo::getBoresightHourAngle);
                cls.def("getInstrumentLabel", &VisitInfo::getInstrumentLabel);
 
                utils::python::addOutputOp(cls, "__str__");
            });
}

FilterProperty() [1/2]

lsst::afw::image::FilterProperty ( FilterProperty &&  )

defaultnoexcept

FilterProperty() [2/2]

lsst::afw::image::FilterProperty ( FilterProperty const &  )

default

fluxErrFromABMagErr() [1/4]

double lsst::afw::image::fluxErrFromABMagErr ( double  magErr, double  mag  )

inlinenoexcept

Compute flux error in Janskys from AB magnitude error and AB magnitude.

Definition at line 60 of file Calib.h.

                                                                      {
    return std::abs(-0.4 * magErr * fluxFromABMag(mag) * std::log(10.0));
}

fluxErrFromABMagErr() [2/4]

template ndarray::Array< double , 1> lsst::afw::image::fluxErrFromABMagErr	(	ndarray::Array< double const, 1 > const &	magErr,
		ndarray::Array< double const, 1 > const &	mag
	)

fluxErrFromABMagErr() [3/4]

template ndarray::Array< float , 1> lsst::afw::image::fluxErrFromABMagErr	(	ndarray::Array< float const, 1 > const &	magErr,
		ndarray::Array< float const, 1 > const &	mag
	)

fluxErrFromABMagErr() [4/4]

template<typename T >

ndarray::Array< T, 1 > lsst::afw::image::fluxErrFromABMagErr	(	ndarray::Array< T const, 1 > const &	magErr,
		ndarray::Array< T const, 1 > const &	mag
	)

Compute flux error in Janskys from AB magnitude error and AB magnitude.

Definition at line 78 of file Calib.cc.

                                                                              {
    if (mag.getNumElements() != magErr.getNumElements()) {
        throw LSST_EXCEPT(pex::exceptions::LengthError, (boost::format("Length mismatch: %d vs %d") %
                                                         mag.getNumElements() % magErr.getNumElements())
                                                                .str());
    }
    ndarray::Array<T, 1> out = ndarray::allocate(mag.getShape());
    for (std::size_t ii = 0; ii < mag.getNumElements(); ++ii) {
        out[ii] = fluxErrFromABMagErr(magErr[ii], mag[ii]);
    }
    return out;
}

fluxFromABMag() [1/4]

double lsst::afw::image::fluxFromABMag ( double  mag )

inlinenoexcept

Compute flux in Janskys from AB magnitude.

Definition at line 57 of file Calib.h.

{ return std::pow(10.0, -0.4 * mag) * JanskysPerABFlux; }

fluxFromABMag() [2/4]

template ndarray::Array< double , 1> lsst::afw::image::fluxFromABMag

(

ndarray::Array< double const, 1 > const &

mag

)

fluxFromABMag() [3/4]

template ndarray::Array< float , 1> lsst::afw::image::fluxFromABMag

(

ndarray::Array< float const, 1 > const &

mag

)

fluxFromABMag() [4/4]

template<typename T >

ndarray::Array< T, 1 > lsst::afw::image::fluxFromABMag

(

ndarray::Array< T const, 1 > const &

mag

)

Compute flux in Janskys from AB magnitude.

Definition at line 68 of file Calib.cc.

                                                                      {
    ndarray::Array<T, 1> out = ndarray::allocate(mag.getShape());
    for (std::size_t ii = 0; ii < mag.getNumElements(); ++ii) {
        out[ii] = fluxFromABMag(mag[ii]);
    }
    return out;
}

for_each_pixel() [1/6]

template<typename LhsT , typename RhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		Image< RhsT > const &	rhs,
		pixelOp1< RhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func(rhs), getting the rhs from an Image<RhsT>

Parameters

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 145 of file ImageAlgorithm.h.

  {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
            *lhsPtr = func(*rhsPtr);
        }
    }
}

for_each_pixel() [2/6]

template<typename LhsT , typename RhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		Image< RhsT > const &	rhs,
		pixelOp2< LhsT, RhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func(lhs, rhs), getting the rhs from an Image<RhsT>

Parameters

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 170 of file ImageAlgorithm.h.

  {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
            *lhsPtr = func(*lhsPtr, *rhsPtr);
        }
    }
}

for_each_pixel() [3/6]

template<typename LhsT , typename RhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		Image< RhsT > const &	rhs,
		pixelOp2XY< LhsT, RhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func(x, y, lhs, rhs), getting the rhs from an Image<RhsT>

(x, y) allow for lhs.getXY0()

Parameters

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 196 of file ImageAlgorithm.h.

  {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
        int x = lhs.getX0();
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
            *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
        }
    }
}

for_each_pixel() [4/6]

template<typename LhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		pixelOp0< LhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func()

Parameters

lhs	Image to set
func	functor to call

Examples

forEachPixel.cc.

Definition at line 97 of file ImageAlgorithm.h.

  {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr) {
            *lhsPtr = func();
        }
    }
}

for_each_pixel() [5/6]

template<typename LhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		pixelOp1< LhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func(lhs)

Parameters

lhs	Image to set
func	functor to call

Definition at line 112 of file ImageAlgorithm.h.

  {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr) {
            *lhsPtr = func(*lhsPtr);
        }
    }
}

for_each_pixel() [6/6]

template<typename LhsT >

void lsst::afw::image::for_each_pixel	(	Image< LhsT > &	lhs,
		pixelOp1XY< LhsT > const &	func
	)

Set each pixel in an Image<LhsT> to func(x, y, lhs)

(x, y) allow for lhs.getXY0()

Parameters

lhs	Image to set
func	functor to call

Definition at line 129 of file ImageAlgorithm.h.

  {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        int x = lhs.getX0();
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr, ++x) {
            *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr);
        }
    }
}

getDatabaseFilterLabel()

std::string lsst::afw::image::getDatabaseFilterLabel

(

std::string const &

filterLabel

)

Remap special characters, etc.

to "_" for database fields.

Returns

The filter label in database-sanitized format.

Definition at line 45 of file FilterLabel.cc.

                                                               {
    static std::regex const unsafeCharacters("\\W"s);
    return std::regex_replace(filterLabel, unsafeCharacters, "_"s);
}

getLambdaEff()

double lsst::afw::image::getLambdaEff ( ) const

noexcept

Return the filter's effective wavelength (nm)

Definition at line 82 of file Filter.h.

{ return _lambdaEff; }

getLambdaMax()

double lsst::afw::image::getLambdaMax ( ) const

noexcept

Return the filter's maximum wavelength (nm) where the transmission is above 1% of the maximum.

Definition at line 90 of file Filter.h.

{ return _lambdaMax; }

getLambdaMin()

double lsst::afw::image::getLambdaMin ( ) const

noexcept

Return the filter's minimum wavelength (nm) where the transmission is above 1% of the maximum.

Definition at line 86 of file Filter.h.

{ return _lambdaMin; }

getName()

std::string const & lsst::afw::image::getName ( ) const

noexcept

Return a filter's name.

Return a Filter's name.

Definition at line 78 of file Filter.h.

{ return _name; }

getPersistenceName()

std::string lsst::afw::image::getPersistenceName ( ) const

overrideprotected

getPythonModule()

std::string lsst::afw::image::getPythonModule ( ) const

overrideprotected

hash_value()

std::size_t lsst::afw::image::hash_value ( ) const

overridenoexcept

Return a hash of this object.

imagesOverlap() [1/2]

template<typename T1 , typename T2 >

bool lsst::afw::image::imagesOverlap	(	ImageBase< T1 > const &	image1,
		ImageBase< T2 > const &	image2
	)

Return true if the pixels for two images or masks overlap in memory.

Definition at line 706 of file Image.cc.

                                                                             {
 
    if (image1.getArea() == 0 || image2.getArea() == 0) {
        // zero-area images cannot overlap.
        return false;
    }
 
    auto arr1 = image1.getArray();
    // get the address of the first and one-past-the-last element of arr1 using ndarray iterators;
    // this works because the iterators for contiguous 1-d ndarray Arrays are just pointers
    auto beg1Addr = arr1.front().begin();
    auto end1Addr = arr1.back().end();
 
    auto arr2 = image2.getArray();
    auto beg2Addr = arr2.front().begin();
    auto end2Addr = arr2.back().end();
 
    auto ptrLess = std::less<void const* const>();
    return ptrLess(beg1Addr, end2Addr) && ptrLess(beg2Addr, end1Addr);
}

imagesOverlap() [2/2]

template<typename ImagePixelT1 , typename ImagePixelT2 >

bool lsst::afw::image::imagesOverlap	(	MaskedImage< ImagePixelT1, MaskPixel, VariancePixel > const &	image1,
		MaskedImage< ImagePixelT2, MaskPixel, VariancePixel > const &	image2
	)

Return true if the pixels for two masked images (image, variance or mask plane) overlap in memory.

Definition at line 685 of file MaskedImage.cc.

                                                                                      {
    return imagesOverlap(*image1.getImage(), *image2.getImage()) ||
           imagesOverlap(*image1.getVariance(), *image2.getVariance()) ||
           imagesOverlap(*image1.getMask(), *image2.getMask());
}

imagesOverlap< double, double >()

template bool lsst::afw::image::imagesOverlap< double, double >	(	MaskedImage< double > const &	,
		MaskedImage< double > const &
	)

imagesOverlap< double, float >()

template bool lsst::afw::image::imagesOverlap< double, float >	(	MaskedImage< double > const &	,
		MaskedImage< float > const &
	)

imagesOverlap< double, int >()

template bool lsst::afw::image::imagesOverlap< double, int >	(	MaskedImage< double > const &	,
		MaskedImage< int > const &
	)

imagesOverlap< double, std::uint16_t >()

template bool lsst::afw::image::imagesOverlap< double, std::uint16_t >	(	MaskedImage< double > const &	,
		MaskedImage< std::uint16_t > const &
	)

imagesOverlap< double, std::uint64_t >()

template bool lsst::afw::image::imagesOverlap< double, std::uint64_t >	(	MaskedImage< double > const &	,
		MaskedImage< std::uint64_t > const &
	)

imagesOverlap< float, double >()

template bool lsst::afw::image::imagesOverlap< float, double >	(	MaskedImage< float > const &	,
		MaskedImage< double > const &
	)

imagesOverlap< float, float >()

template bool lsst::afw::image::imagesOverlap< float, float >	(	MaskedImage< float > const &	,
		MaskedImage< float > const &
	)

imagesOverlap< float, int >()

template bool lsst::afw::image::imagesOverlap< float, int >	(	MaskedImage< float > const &	,
		MaskedImage< int > const &
	)

imagesOverlap< float, std::uint16_t >()

template bool lsst::afw::image::imagesOverlap< float, std::uint16_t >	(	MaskedImage< float > const &	,
		MaskedImage< std::uint16_t > const &
	)

imagesOverlap< float, std::uint64_t >()

template bool lsst::afw::image::imagesOverlap< float, std::uint64_t >	(	MaskedImage< float > const &	,
		MaskedImage< std::uint64_t > const &
	)

imagesOverlap< int, double >()

template bool lsst::afw::image::imagesOverlap< int, double >	(	MaskedImage< int > const &	,
		MaskedImage< double > const &
	)

imagesOverlap< int, float >()

template bool lsst::afw::image::imagesOverlap< int, float >	(	MaskedImage< int > const &	,
		MaskedImage< float > const &
	)

imagesOverlap< int, int >()

template bool lsst::afw::image::imagesOverlap< int, int >	(	MaskedImage< int > const &	,
		MaskedImage< int > const &
	)

imagesOverlap< int, std::uint16_t >()

template bool lsst::afw::image::imagesOverlap< int, std::uint16_t >	(	MaskedImage< int > const &	,
		MaskedImage< std::uint16_t > const &
	)

imagesOverlap< int, std::uint64_t >()

template bool lsst::afw::image::imagesOverlap< int, std::uint64_t >	(	MaskedImage< int > const &	,
		MaskedImage< std::uint64_t > const &
	)

imagesOverlap< std::uint16_t, double >()

template bool lsst::afw::image::imagesOverlap< std::uint16_t, double >	(	MaskedImage< std::uint16_t > const &	,
		MaskedImage< double > const &
	)

imagesOverlap< std::uint16_t, float >()

template bool lsst::afw::image::imagesOverlap< std::uint16_t, float >	(	MaskedImage< std::uint16_t > const &	,
		MaskedImage< float > const &
	)

imagesOverlap< std::uint16_t, int >()

template bool lsst::afw::image::imagesOverlap< std::uint16_t, int >	(	MaskedImage< std::uint16_t > const &	,
		MaskedImage< int > const &
	)

imagesOverlap< std::uint16_t, std::uint16_t >()

template bool lsst::afw::image::imagesOverlap< std::uint16_t, std::uint16_t >	(	MaskedImage< std::uint16_t > const &	,
		MaskedImage< std::uint16_t > const &
	)

imagesOverlap< std::uint16_t, std::uint64_t >()

template bool lsst::afw::image::imagesOverlap< std::uint16_t, std::uint64_t >	(	MaskedImage< std::uint16_t > const &	,
		MaskedImage< std::uint64_t > const &
	)

imagesOverlap< std::uint64_t, double >()

template bool lsst::afw::image::imagesOverlap< std::uint64_t, double >	(	MaskedImage< std::uint64_t > const &	,
		MaskedImage< double > const &
	)

imagesOverlap< std::uint64_t, float >()

template bool lsst::afw::image::imagesOverlap< std::uint64_t, float >	(	MaskedImage< std::uint64_t > const &	,
		MaskedImage< float > const &
	)

imagesOverlap< std::uint64_t, int >()

template bool lsst::afw::image::imagesOverlap< std::uint64_t, int >	(	MaskedImage< std::uint64_t > const &	,
		MaskedImage< int > const &
	)

imagesOverlap< std::uint64_t, std::uint16_t >()

template bool lsst::afw::image::imagesOverlap< std::uint64_t, std::uint16_t >	(	MaskedImage< std::uint64_t > const &	,
		MaskedImage< std::uint16_t > const &
	)

imagesOverlap< std::uint64_t, std::uint64_t >()

template bool lsst::afw::image::imagesOverlap< std::uint64_t, std::uint64_t >	(	MaskedImage< std::uint64_t > const &	,
		MaskedImage< std::uint64_t > const &
	)

indexToPosition()

double lsst::afw::image::indexToPosition ( double  ind )

inline

Convert image index to image position.

The LSST indexing convention is:

• the index of the bottom left pixel is 0,0
• the position of the center of the bottom left pixel is PixelZeroPos, PixelZeroPos

Returns

image position

Parameters

ind	image index

Definition at line 55 of file ImageUtils.h.

  {
    return ind + PixelZeroPos;
}

innerProduct()

template<typename Image1T , typename Image2T >

double lsst::afw::image::innerProduct	(	Image1T const &	lhs,
		Image2T const &	rhs,
		int const	border = 0
	)

Calculate the inner product of two images.

Parameters

lhs	first image
rhs	Other image to dot with first
border	number of pixels to ignore around the edge

Returns

The inner product

Exceptions

lsst::pex::exceptions::LengthError

if all the images aren't the same size

Definition at line 415 of file ImagePca.cc.

                                                                        {
    if (lhs.getWidth() <= 2 * border || lhs.getHeight() <= 2 * border) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("All image pixels are in the border of width %d: %dx%d") % border %
                           lhs.getWidth() % lhs.getHeight())
                                  .str());
    }
 
    double sum = 0.0;
    //
    // Handle I.I specially for efficiency, and to avoid advancing the iterator twice
    //
    if (imagesAreIdentical(lhs, rhs)) {
        for (int y = border; y != lhs.getHeight() - border; ++y) {
            for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
                                                    lend = lhs.row_end(y) - border;
                 lptr != lend; ++lptr) {
                typename Image1T::Pixel val = *lptr;
                if (std::isfinite(val)) {
                    sum += val * val;
                }
            }
        }
    } else {
        if (lhs.getDimensions() != rhs.getDimensions()) {
            throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                              (boost::format("Dimension mismatch: %dx%d v. %dx%d") % lhs.getWidth() %
                               lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                      .str());
        }
 
        for (int y = border; y != lhs.getHeight() - border; ++y) {
            typename Image2T::const_x_iterator rptr = rhs.row_begin(y) + border;
            for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
                                                    lend = lhs.row_end(y) - border;
                 lptr != lend; ++lptr, ++rptr) {
                double const tmp = (*lptr) * (*rptr);
                if (std::isfinite(tmp)) {
                    sum += tmp;
                }
            }
        }
    }
 
    return sum;
}

makeExposure()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT> > lsst::afw::image::makeExposure	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &	mimage,
		std::shared_ptr< geom::SkyWcs const >	wcs = std::shared_ptr<geom::SkyWcs const>()
	)

A function to return an Exposure of the correct type (cf.

std::make_pair)

Parameters

mimage	the Exposure's image
wcs	the Exposure's WCS

Definition at line 462 of file Exposure.h.

  {
    return typename std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT>>(
            new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
}

makeFilter()

Filter lsst::afw::image::makeFilter

(

FilterLabel const &

label

)

Convert a FilterLabel back to an old-style Filter.

Parameters

label

The FilterLabel to convert.

Returns

The closest equivalent Filter, following the conventions established by obs.base.FilterDefinition.

Definition at line 210 of file ExposureFitsReader.cc.

                                            {
    // Filters still have standard aliases, so can use almost any name to define them.
    // Prefer afw_name or band because that's what most code assumes is Filter.getName().
    for (auto const& keyValue : _AFW_NAMES) {
        std::string const& afwName = keyValue.first;
        FilterLabel const& afwFilter = keyValue.second;
        if (label == afwFilter) {
            return Filter(afwName);
        }
    }
 
    if (label.hasBandLabel()) {
        return Filter(label.getBandLabel(), true);
    } else {
        // FilterLabel guarantees at least one of band or physical is defined.
        return Filter(label.getPhysicalLabel(), true);
    }
}

makeFilterLabel() [1/2]

std::shared_ptr< FilterLabel > lsst::afw::image::makeFilterLabel

(

Filter const &

filter

)

Convert an old-style Filter to a FilterLabel.

If a filter has been declared using lsst.obs.base.FilterDefinition, that information (as encoded in the ~lsst.afw.image.Filter registry) is used to infer the filter's band and physical filter.

Parameters

filter

Any Filter object.

Returns

The closest equivalent FilterLabel, given available information.

Definition at line 121 of file ExposureFitsReader.cc.

                                                                 {
    static Filter const DEFAULT;
    // Avoid turning dummy filters into real FilterLabels.
    // Default filter has id=UNKNOWN, but others do too.
    if (filter.getId() == DEFAULT.getId() && filter.getName() == DEFAULT.getName()) {
        return nullptr;
    }
 
    // Filter has no self-consistency guarantees whatsoever, and most methods
    // are unsafe. Program extremely defensively.
    if (filter.getId() == Filter::UNKNOWN) {
        // Not a registered filter; guarantees on canonical name do not apply
        return makeFilterLabelDirect(filter.getName());
    }
 
    // obs.base.FilterDefinition ensures the canonical name is the first defined
    // of afwname, band name, physical filter name.
    std::string canonical;
    try {
        canonical = filter.getCanonicalName();
    } catch (pex::exceptions::NotFoundError const&) {
        // Not a registered filter; guarantees on canonical name do not apply
        return makeFilterLabelDirect(filter.getName());
    }
 
    if (_AFW_NAMES.count(canonical) > 0) {
        return std::make_shared<FilterLabel>(_AFW_NAMES.at(canonical));
    } else if (_isBand(canonical)) {
        // physical filter is one of the aliases, but can't tell which one
        // (FilterDefinition helpfully sorts them). Safer to leave it blank.
        std::vector<std::string> aliases;
        try {
            aliases = filter.getAliases();
        } catch (pex::exceptions::NotFoundError const&) {
            // No aliases; leave the vector empty
        }
        if (aliases.size() == 1) {
            return std::make_shared<FilterLabel>(FilterLabel::fromBandPhysical(canonical, aliases.front()));
        } else {
            return std::make_shared<FilterLabel>(FilterLabel::fromBand(canonical));
        }
    } else {
        return std::make_shared<FilterLabel>(FilterLabel::fromPhysical(canonical));
    }
}

makeFilterLabel() [2/2]

std::shared_ptr<FilterLabel> lsst::afw::image::makeFilterLabel

(

std::string const &

name

)

Convert an old-style single Filter name to a FilterLabel, using available information.

If a filter has been declared using lsst.obs.base.FilterDefinition, that information (as encoded in the ~lsst.afw.image.Filter registry) is used to infer the filter's band and physical filter.

Parameters

name	The name persisted in a FITS file. May be any of a Filter's many names.

Returns

The closest equivalent FilterLabel, given available information.

Definition at line 177 of file ExposureFitsReader.cc.

                                                                  {
    if (_AFW_NAMES.count(name) > 0) {
        return std::make_shared<FilterLabel>(_AFW_NAMES.at(name));
    }
    // else name is either a band, a physical filter, or a deprecated alias
 
    try {
        // To ease the transition to FilterLabel, use Filter to get all the names
        // TODO: after DM-27177, leave only the catch block
        Filter filter(name, false);
        std::shared_ptr<FilterLabel> converted = makeFilterLabel(filter);
        // Make use of the extra information that `name` is a preferred name
        // If name is not a band, it is likely the physical filter
        if (converted && !converted->hasPhysicalLabel() && converted->hasBandLabel() &&
            name != converted->getBandLabel()) {
            return std::make_shared<FilterLabel>(
                    FilterLabel::fromBandPhysical(converted->getBandLabel(), name));
        } else {
            return converted;
        }
    } catch (pex::exceptions::NotFoundError const&) {
        // Unknown filter, no extra info to be gained
        return makeFilterLabelDirect(name);
    }
}

makeFilterLabelDirect()

std::shared_ptr<FilterLabel> lsst::afw::image::makeFilterLabelDirect

(

std::string const &

name

)

Convert an old-style filter name to a FilterLabel without external information.

Guaranteed to not call any code related to Filter or FilterDefinition.

Parameters

name	A name for the filter.

Returns

A FilterLabel containing that name.

Definition at line 94 of file ExposureFitsReader.cc.

                                                                        {
    static Filter const DEFAULT;
    // Avoid turning dummy filters into real FilterLabels.
    if (name == DEFAULT.getName()) {
        return nullptr;
    }
 
    // FilterLabel::from* returns a statically allocated object, so only way
    // to get it into shared_ptr is to copy it.
    if (_isBand(name)) {
        return std::make_shared<FilterLabel>(FilterLabel::fromBand(name));
    } else {
        return std::make_shared<FilterLabel>(FilterLabel::fromPhysical(name));
    }
}

makeMaskedImage()

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>* lsst::afw::image::makeMaskedImage	(	typename std::shared_ptr< Image< ImagePixelT >>	image,
		typename std::shared_ptr< Mask< MaskPixelT >>	mask = Mask<MaskPixelT>(),
		typename std::shared_ptr< Image< VariancePixelT >>	variance = Image<VariancePixelT>()
	)

A function to return a MaskedImage of the correct type (cf.

std::make_pair)

Parameters

image	image
mask	mask
variance	variance

Definition at line 1268 of file MaskedImage.h.

  {
    return new MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(image, mask, variance);
}

makePhotoCalibFromCalibZeroPoint()

std::shared_ptr< PhotoCalib > lsst::afw::image::makePhotoCalibFromCalibZeroPoint	(	double	instFluxMag0,
		double	instFluxMag0Err
	)

Construct a PhotoCalib from the deprecated Calib-style instFluxMag0/instFluxMag0Err values.

This provides backwards compatibility with the obsoleted Calib object that PhotoCalib replaced. It should not be used outside of tests that compare with old persisted Calib objects.

Parameters

instFluxMag0	The instrumental flux at zero magnitude. If 0, the resulting PhotoCalib will have infinite calibrationMean and non-finite (inf or NaN) calibrationErr.
instFluxMag0Err	The instrumental flux at zero magnitude error. If 0, the resulting PhotoCalib will have 0 calibrationErr.

Returns

Pointer to the constructed PhotoCalib.

Definition at line 614 of file PhotoCalib.cc.

                                                                                                        {
    double calibration = utils::referenceFlux / instFluxMag0;
    double calibrationErr = utils::referenceFlux * instFluxMag0Err / std::pow(instFluxMag0, 2);
    return std::make_shared<PhotoCalib>(calibration, calibrationErr);
}

makePhotoCalibFromMetadata()

std::shared_ptr< PhotoCalib > lsst::afw::image::makePhotoCalibFromMetadata	(	daf::base::PropertySet &	metadata,
		bool	strip = false
	)

Construct a PhotoCalib from FITS FLUXMAG0/FLUXMAG0ERR keywords.

This provides backwards compatibility with the obsoleted Calib object that PhotoCalib replaced. It should not be used outside of reading old Exposures written before PhotoCalib existed.

Parameters

metadata	FITS header metadata containing FLUXMAG0 and FLUXMAG0ERR keys.
strip	Strip FLUXMAG0 and FLUXMAG0ERR from metadata?

Returns

Pointer to the constructed PhotoCalib, or nullptr if FLUXMAG0 is not in the metadata.

Definition at line 596 of file PhotoCalib.cc.

                                                                                               {
    auto key = "FLUXMAG0";
    if (metadata.exists(key)) {
        double instFluxMag0 = metadata.getAsDouble(key);
        if (strip) metadata.remove(key);
 
        double instFluxMag0Err = 0.0;
        key = "FLUXMAG0ERR";
        if (metadata.exists(key)) {
            instFluxMag0Err = metadata.getAsDouble(key);
            if (strip) metadata.remove(key);
        }
        return makePhotoCalibFromCalibZeroPoint(instFluxMag0, instFluxMag0Err);
    } else {
        return nullptr;
    }
}

operator!=()

bool lsst::afw::image::operator!= ( FilterProperty const &  rhs ) const

noexcept

Return true iff rhs != this.

Parameters

rhs	Object to compare with this

Definition at line 100 of file Filter.h.

                                     {
        return !(*this == rhs);
    }

operator*() [1/2]

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator*	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator*()

We'll define both 'image*slice' (this one) and 'slice*image' (next one down).

Parameters

img	The Image
slc	The ImageSlice

Definition at line 104 of file ImageSlice.cc.

                                                                                                {
    std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
    *retImg *= slc;
    return retImg;
}

operator*() [2/2]

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator*	(	ImageSlice< PixelT > const &	slc,
		Image< PixelT > const &	img
	)

Overload operator*()

We'll define both 'image*slice' (this one) and 'slice*image' (next one down).

Parameters

slc	The Image
img	The ImageSlice

Definition at line 111 of file ImageSlice.cc.

                                                                                                {
    return operator*(img, slc);
}

operator*=() [1/2]

template<typename LhsPixelT , typename RhsPixelT >

Image< LhsPixelT > & lsst::afw::image::operator*=	(	Image< LhsPixelT > &	lhs,
		Image< RhsPixelT > const &	rhs
	)

Multiply lhs by Image rhs (i.e. pixel-by-pixel multiplication) where types are different.

Definition at line 683 of file Image.cc.

                                                                                 {
    for_each_pixel(lhs, rhs, timesEq<LhsPixelT, RhsPixelT>());
    return lhs;
}

operator*=() [2/2]

template<typename PixelT >

void lsst::afw::image::operator*=	(	Image< PixelT > &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator*=()

Only 'image *= slice' is defined, as 'slice *= image' doesn't make sense.

Parameters

[in,out]	img	The Image
[in]	slc	The ImageSlice

Definition at line 116 of file ImageSlice.cc.

                                                                   {
    details::operate<details::Mult<PixelT>>(img, slc, slc.getImageSliceType());
}

operator+() [1/2]

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator+	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator+()

We require two of these, one for image+slice (this one) and one for slice+image (next one down)

Parameters

img	The Image
slc	The ImageSlice

Definition at line 69 of file ImageSlice.cc.

                                                                                                {
    std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
    *retImg += slc;
    return retImg;
}

operator+() [2/2]

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator+	(	ImageSlice< PixelT > const &	slc,
		Image< PixelT > const &	img
	)

Overload operator+()

Parameters

slc	The ImageSlice
img	The Image

We require two of these, one for image+slice (previous one) and one for slice+image (this)

Definition at line 76 of file ImageSlice.cc.

                                                                                                {
    return operator+(img, slc);
}

operator+=() [1/2]

template<typename LhsPixelT , typename RhsPixelT >

Image< LhsPixelT > & lsst::afw::image::operator+=	(	Image< LhsPixelT > &	lhs,
		Image< RhsPixelT > const &	rhs
	)

Add lhs to Image rhs (i.e. pixel-by-pixel addition) where types are different.

Definition at line 671 of file Image.cc.

                                                                                 {
    for_each_pixel(lhs, rhs, plusEq<LhsPixelT, RhsPixelT>());
    return lhs;
}

operator+=() [2/2]

template<typename PixelT >

void lsst::afw::image::operator+=	(	Image< PixelT > &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator+=()

We'll only allow 'image += slice'. It doesn't make sense to add an image to a slice.

Parameters

[in,out]	img	The Image
[in]	slc	The ImageSlice

Definition at line 81 of file ImageSlice.cc.

                                                                   {
    details::operate<details::Plus<PixelT>>(img, slc, slc.getImageSliceType());
}

operator-()

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator-	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator-()

We'll only allow 'image - slice', as 'slice - image' doesn't make sense.

Parameters

img	The Image
slc	The ImageSlice

Definition at line 89 of file ImageSlice.cc.

                                                                                                {
    std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
    *retImg -= slc;
    return retImg;
}

operator-=() [1/2]

template<typename LhsPixelT , typename RhsPixelT >

Image< LhsPixelT > & lsst::afw::image::operator-=	(	Image< LhsPixelT > &	lhs,
		Image< RhsPixelT > const &	rhs
	)

Subtract lhs from Image rhs (i.e. pixel-by-pixel subtraction) where types are different.

Definition at line 677 of file Image.cc.

                                                                                 {
    for_each_pixel(lhs, rhs, minusEq<LhsPixelT, RhsPixelT>());
    return lhs;
}

operator-=() [2/2]

template<typename PixelT >

void lsst::afw::image::operator-=	(	Image< PixelT > &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator-=()

Only 'image -= slice' is defined. 'slice -= image' wouldn't make sense.

Parameters

[in,out]	img	The Image
[in]	slc	The ImageSlice

Definition at line 96 of file ImageSlice.cc.

                                                                   {
    details::operate<details::Minus<PixelT>>(img, slc, slc.getImageSliceType());
}

operator/()

template<typename PixelT >

std::shared_ptr< Image< PixelT > > lsst::afw::image::operator/	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator/()

Only 'image / slice' is defined, as 'slice / image' doesn't make sense.

Parameters

img	The Image
slc	The ImageSlice

Definition at line 123 of file ImageSlice.cc.

                                                                                                {
    std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
    *retImg /= slc;
    return retImg;
}

operator/=() [1/2]

template<typename LhsPixelT , typename RhsPixelT >

Image< LhsPixelT > & lsst::afw::image::operator/=	(	Image< LhsPixelT > &	lhs,
		Image< RhsPixelT > const &	rhs
	)

Divide lhs by Image rhs (i.e. pixel-by-pixel division) where types are different.

Definition at line 689 of file Image.cc.

                                                                                 {
    for_each_pixel(lhs, rhs, divideEq<LhsPixelT, RhsPixelT>());
    return lhs;
}

operator/=() [2/2]

template<typename PixelT >

void lsst::afw::image::operator/=	(	Image< PixelT > &	img,
		ImageSlice< PixelT > const &	slc
	)

Overload operator/=()

Only 'image /= slice' is defined, as 'slice /= image' doesn't make sense.

Parameters

[in,out]	img	The Image
[in]	slc	The ImageSlice

Definition at line 130 of file ImageSlice.cc.

                                                                   {
    details::operate<details::Div<PixelT>>(img, slc, slc.getImageSliceType());
}

operator<<() [1/3]

std::ostream & lsst::afw::image::operator<<	(	std::ostream &	os,
		Measurement const &	measurement
	)

Definition at line 48 of file PhotoCalib.cc.

                                                                       {
    std::stringstream s;
    s << std::setprecision(std::numeric_limits<long double>::digits10 + 1);
    s << "value=" << measurement.value << ", error=" << measurement.error;
    return os << s.str();
}

operator<<() [2/3]

std::ostream& lsst::afw::image::operator<<	(	std::ostream &	os,
		PhotoCalib const &	photoCalib
	)

Definition at line 257 of file PhotoCalib.cc.

                                                                     {
    return os << photoCalib.toString();
}

operator<<() [3/3]

std::ostream & lsst::afw::image::operator<<	(	std::ostream &	os,
		VisitInfo const &	visitInfo
	)

Definition at line 550 of file VisitInfo.cc.

                                                                   {
    os << visitInfo.toString();
    return os;
}

operator=() [1/2]

FilterProperty& lsst::afw::image::operator= ( FilterProperty &&  )

defaultnoexcept

operator=() [2/2]

FilterProperty& lsst::afw::image::operator= ( FilterProperty const &  )

default

operator==()

bool lsst::afw::image::operator== ( FilterProperty const &  rhs ) const

noexcept

Return true iff two FilterProperties are identical.

Parameters

rhs	Object to compare with this

positionToIndex() [1/3]

int lsst::afw::image::positionToIndex ( double &  residual, double  pos  )

inline

Convert image position to index (nearest integer and fractional parts)

The LSST indexing convention is:

• the index of the bottom left pixel is 0,0
• the position of the center of the bottom left pixel is PixelZeroPos, PixelZeroPos

Note: in python this is called positionToIndexAndResidual

Returns

nearest integer index

Parameters

residual	fractional part of index
pos	image position

Definition at line 85 of file ImageUtils.h.

  {
    double fullIndex = pos - PixelZeroPos;
    double roundedIndex = std::floor(fullIndex + 0.5);
    residual = fullIndex - roundedIndex;
    return static_cast<int>(roundedIndex);
}

positionToIndex() [2/3]

std::pair<int, double> lsst::afw::image::positionToIndex ( double const  pos, bool    )

inline

Convert image position to index (nearest integer and fractional parts)

Returns

std::pair(nearest integer index, fractional part)

Parameters

pos	image position

Definition at line 98 of file ImageUtils.h.

  {
    double residual;                                 // fractional part of index
    int const ind = positionToIndex(residual, pos);  // integral part
 
    return std::pair<int, double>(ind, residual);
}

positionToIndex() [3/3]

int lsst::afw::image::positionToIndex ( double  pos )

inline

Convert image position to nearest integer index.

The LSST indexing convention is:

• the index of the bottom left pixel is 0,0
• the position of the center of the bottom left pixel is PixelZeroPos, PixelZeroPos

Returns

nearest integer index

Parameters

pos	image position

Definition at line 69 of file ImageUtils.h.

  {
    return static_cast<int>(std::floor(pos + 0.5 - PixelZeroPos));
}

PYBIND11_MODULE() [1/3]

lsst::afw::image::PYBIND11_MODULE	(	_exposure	,
		mod
	)

Definition at line 166 of file _exposure.cc.

                                {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image.exposure");
    wrappers.addSignatureDependency("lsst.afw.image.apCorrMap");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrappers.addSignatureDependency("lsst.afw.detection");
    wrappers.addSignatureDependency("lsst.afw.image.maskedImage");
 
    auto clsExposureF = declareExposure<float>(wrappers, "F");
    auto clsExposureD = declareExposure<double>(wrappers, "D");
    declareExposure<int>(wrappers, "I");
    declareExposure<std::uint16_t>(wrappers, "U");
    declareExposure<std::uint64_t>(wrappers, "L");
 
    // Declare constructors for casting all exposure types to to float and double
    // (the only two types of casts that Python supports)
    declareCastConstructor<int, float>(clsExposureF);
    declareCastConstructor<int, double>(clsExposureD);
 
    declareCastConstructor<float, double>(clsExposureD);
    declareCastConstructor<double, float>(clsExposureF);
 
    declareCastConstructor<std::uint16_t, float>(clsExposureF);
    declareCastConstructor<std::uint16_t, double>(clsExposureD);
 
    declareCastConstructor<std::uint64_t, float>(clsExposureF);
    declareCastConstructor<std::uint64_t, double>(clsExposureD);
 
    wrappers.finish();
}

PYBIND11_MODULE() [2/3]

lsst::afw::image::PYBIND11_MODULE	(	_imageLib	,
		mod
	)

Definition at line 45 of file _imageLib.cc.

                                {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image");
    wrapCalib(wrappers);
    wrapColor(wrappers);
    wrapCoaddInputs(wrappers);
    wrapDefect(wrappers);
    wrapExposureInfo(wrappers);
    wrapFilter(wrappers);
    wrapFilterLabel(wrappers);
    wrapImagePca(wrappers);
    wrapImageUtils(wrappers);
    wrapPhotoCalib(wrappers);
    wrapReaders(wrappers);
    wrapTransmissionCurve(wrappers);
    wrapVisitInfo(wrappers);
    wrappers.finish();
}

PYBIND11_MODULE() [3/3]

lsst::afw::image::PYBIND11_MODULE	(	_maskedImage	,
		mod
	)

Definition at line 244 of file _maskedImage.cc.

                                   {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image.maskedImage");
    wrappers.addSignatureDependency("lsst.afw.image.image");
    wrappers.addInheritanceDependency("lsst.daf.base");
 
    auto clsMaskedImageF = declareMaskedImage<float>(wrappers, "F");
    auto clsMaskedImageD = declareMaskedImage<double>(wrappers, "D");
    auto clsMaskedImageI = declareMaskedImage<int>(wrappers, "I");
    auto clsMaskedImageU = declareMaskedImage<std::uint16_t>(wrappers, "U");
    auto clsMaskedImageL = declareMaskedImage<std::uint64_t>(wrappers, "L");
 
    // Declare constructors for casting all exposure types to to float and double
    // (the only two types of casts that Python supports)
    declareCastConstructor<int, float>(clsMaskedImageF);
    declareCastConstructor<int, double>(clsMaskedImageD);
    declareCastConstructor<float, double>(clsMaskedImageD);
    declareCastConstructor<double, float>(clsMaskedImageF);
    declareCastConstructor<std::uint16_t, float>(clsMaskedImageF);
    declareCastConstructor<std::uint16_t, double>(clsMaskedImageD);
    declareCastConstructor<std::uint64_t, float>(clsMaskedImageF);
    declareCastConstructor<std::uint64_t, double>(clsMaskedImageD);
 
    /* Module level */
    declareMakeMaskedImage<int>(wrappers);
    declareMakeMaskedImage<float>(wrappers);
    declareMakeMaskedImage<double>(wrappers);
    declareMakeMaskedImage<std::uint16_t>(wrappers);
    declareMakeMaskedImage<std::uint64_t>(wrappers);
 
    declareImagesOverlap<int, int>(wrappers);
    declareImagesOverlap<int, float>(wrappers);
    declareImagesOverlap<int, double>(wrappers);
    declareImagesOverlap<int, std::uint16_t>(wrappers);
    declareImagesOverlap<int, std::uint64_t>(wrappers);
 
    declareImagesOverlap<float, int>(wrappers);
    declareImagesOverlap<float, float>(wrappers);
    declareImagesOverlap<float, double>(wrappers);
    declareImagesOverlap<float, std::uint16_t>(wrappers);
    declareImagesOverlap<float, std::uint64_t>(wrappers);
 
    declareImagesOverlap<double, int>(wrappers);
    declareImagesOverlap<double, float>(wrappers);
    declareImagesOverlap<double, double>(wrappers);
    declareImagesOverlap<double, std::uint16_t>(wrappers);
    declareImagesOverlap<double, std::uint64_t>(wrappers);
 
    declareImagesOverlap<std::uint16_t, int>(wrappers);
    declareImagesOverlap<std::uint16_t, float>(wrappers);
    declareImagesOverlap<std::uint16_t, double>(wrappers);
    declareImagesOverlap<std::uint16_t, std::uint16_t>(wrappers);
    declareImagesOverlap<std::uint16_t, std::uint64_t>(wrappers);
 
    declareImagesOverlap<std::uint64_t, int>(wrappers);
    declareImagesOverlap<std::uint64_t, float>(wrappers);
    declareImagesOverlap<std::uint64_t, double>(wrappers);
    declareImagesOverlap<std::uint64_t, std::uint16_t>(wrappers);
    declareImagesOverlap<std::uint64_t, std::uint64_t>(wrappers);
    wrappers.finish();
}

swap() [1/4]

template<typename PixelT >

void lsst::afw::image::swap	(	DecoratedImage< PixelT > &	a,
		DecoratedImage< PixelT > &	b
	)

Definition at line 90 of file DecoratedImage.cc.

                                                                {
    a.swap(b);
}

swap() [2/4]

template<typename PixelT >

void lsst::afw::image::swap	(	Image< PixelT > &	a,
		Image< PixelT > &	b
	)

Definition at line 456 of file Image.cc.

                                              {
    a.swap(b);
}

swap() [3/4]

template<typename PixelT >

void lsst::afw::image::swap	(	ImageBase< PixelT > &	a,
		ImageBase< PixelT > &	b
	)

Definition at line 255 of file Image.cc.

                                                      {
    a.swap(b);
}

swap() [4/4]

template<typename PixelT >

void lsst::afw::image::swap	(	Mask< PixelT > &	a,
		Mask< PixelT > &	b
	)

Definition at line 141 of file Mask.cc.

                                            {
    a.swap(b);
}

wrapCalib()

void lsst::afw::image::wrapCalib

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 69 of file _calib.cc.

                                                           {
    /* Module level */
    declareCalib(wrappers);
    declareVectorOperations<float>(wrappers);
    declareVectorOperations<double>(wrappers);
}

wrapCoaddInputs()

void lsst::afw::image::wrapCoaddInputs

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 42 of file _coaddInputs.cc.

                                                                 {
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    wrappers.wrapType(PyCoaddInputs(wrappers.module, "CoaddInputs"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<>());
        cls.def(py::init<table::Schema const &, table::Schema const &>(), "visitSchema"_a, "ccdSchema"_a);
        cls.def(py::init<table::ExposureCatalog const &, table::ExposureCatalog const &>(), "visits"_a,
                "ccds"_a);
 
        table::io::python::addPersistableMethods<CoaddInputs>(cls);
 
        /* Members */
        cls.def_readwrite("visits", &CoaddInputs::visits);
        cls.def_readwrite("ccds", &CoaddInputs::ccds);
        cls.def("isPersistable", &CoaddInputs::isPersistable);
    });
}

wrapColor()

void lsst::afw::image::wrapColor

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 40 of file _color.cc.

                                                           {
    /* Module level */
    wrappers.wrapType(PyColor(wrappers.module, "Color"), [](auto &mod, auto &cls) {
        /* Constructors */
        cls.def(py::init<double>(), "g_r"_a = std::numeric_limits<double>::quiet_NaN());
 
        /* Operators */
        cls.def(
                "__eq__", [](Color const &self, Color const &other) { return self == other; },
                py::is_operator());
        cls.def(
                "__ne__", [](Color const &self, Color const &other) { return self != other; },
                py::is_operator());
 
        /* Members */
        cls.def("isIndeterminate", &Color::isIndeterminate);
        cls.def("getLambdaEff", &Color::getLambdaEff, "filter"_a);
    });
}

wrapDefect()

void lsst::afw::image::wrapDefect

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 56 of file _defect.cc.

                                                            {
    wrappers.addSignatureDependency("lsst.afw.geom");
    declareDefects(wrappers);
}

wrapExposure()

void lsst::afw::image::wrapExposure

(

lsst::utils::python::WrapperCollection &

)

wrapExposureInfo()

void lsst::afw::image::wrapExposureInfo

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 207 of file _exposureInfo.cc.

                                                                  {
    wrappers.addSignatureDependency("lsst.daf.base");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrappers.addSignatureDependency("lsst.afw.cameraGeom");
    wrappers.addSignatureDependency("lsst.afw.detection");  // For Psf
    declareExposureInfo(wrappers);
}

wrapFilter()

void lsst::afw::image::wrapFilter

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 98 of file _filter.cc.

                                                            {
    wrappers.addSignatureDependency("lsst.daf.base");
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    declareFilterProperty(wrappers);
    declareFilter(wrappers);
    wrappers.wrap(
            [](auto &mod) { mod.def("stripFilterKeywords", &detail::stripFilterKeywords, "metadata"_a); });
}

wrapFilterLabel()

void lsst::afw::image::wrapFilterLabel

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 116 of file _filterLabel.cc.

                                                                 {
    // import inheritance dependencies
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    declareFilterLabel(wrappers);
    wrappers.wrap(
            [](auto &mod) { mod.def("getDatabaseFilterLabel", &getDatabaseFilterLabel, "filterLabel"_a); });
}

wrapImage()

void lsst::afw::image::wrapImage

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 448 of file _image.cc.

                                                           {
    wrappers.addSignatureDependency("lsst.daf.base");
    wrappers.addSignatureDependency("lsst.geom");
    wrappers.wrapType(py::enum_<ImageOrigin>(wrappers.module, "ImageOrigin"), [](auto &mod, auto &enm) {
        enm.value("PARENT", ImageOrigin::PARENT);
        enm.value("LOCAL", ImageOrigin::LOCAL);
        enm.export_values();
    });
 
    declareImageBase<int>(wrappers, "I");
    declareImageBase<float>(wrappers, "F");
    declareImageBase<double>(wrappers, "D");
    declareImageBase<std::uint16_t>(wrappers, "U");
    declareImageBase<std::uint64_t>(wrappers, "L");
 
    // Mask must be declared before Image because a mask is used as a default value in at least one method
    declareMask<MaskPixel>(wrappers, "X");
 
    auto clsImageI = declareImage<int>(wrappers, "I");
    auto clsImageF = declareImage<float>(wrappers, "F");
    auto clsImageD = declareImage<double>(wrappers, "D");
    auto clsImageU = declareImage<std::uint16_t>(wrappers, "U");
    auto clsImageL = declareImage<std::uint64_t>(wrappers, "L");
 
    // Add generalized copy constructors
    addGeneralizedCopyConstructors<int>(clsImageI);
    addGeneralizedCopyConstructors<float>(clsImageF);
    addGeneralizedCopyConstructors<double>(clsImageD);
    addGeneralizedCopyConstructors<std::uint16_t>(clsImageU);
    addGeneralizedCopyConstructors<std::uint64_t>(clsImageL);
 
    // Add slice operators only for float and double
    addImageSliceOperators<float>(clsImageF);
    addImageSliceOperators<double>(clsImageD);
 
    declareDecoratedImage<int>(wrappers, "I");
    declareDecoratedImage<float>(wrappers, "F");
    declareDecoratedImage<double>(wrappers, "D");
    declareDecoratedImage<std::uint16_t>(wrappers, "U");
    declareDecoratedImage<std::uint64_t>(wrappers, "L");
 
    // Declare constructors for casting all exposure types to to float and double
    // (the only two types of casts that Python supports)
    declareCastConstructor<int, float>(clsImageF);
    declareCastConstructor<int, double>(clsImageD);
 
    declareCastConstructor<float, double>(clsImageD);
 
    declareCastConstructor<double, float>(clsImageF);
 
    declareCastConstructor<std::uint16_t, float>(clsImageF);
    declareCastConstructor<std::uint16_t, double>(clsImageD);
 
    declareCastConstructor<std::uint64_t, float>(clsImageF);
    declareCastConstructor<std::uint64_t, double>(clsImageD);
 
    // Note: wrap both the Image and MaskedImage versions of imagesOverlap in the MaskedImage wrapper,
    // as wrapping the Image version here results in it being invisible in lsst.afw.image
    wrappers.wrap([](auto &mod) { mod.def("bboxFromMetadata", &bboxFromMetadata); });
}

wrapImagePca()

void lsst::afw::image::wrapImagePca

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 73 of file _imagePca.cc.

                                                              {
    declareImagePca<Image<int>>(wrappers, "I");
    declareImagePca<Image<float>>(wrappers, "F");
    declareImagePca<Image<double>>(wrappers, "D");
    declareImagePca<Image<std::uint16_t>>(wrappers, "U");
    declareImagePca<Image<std::uint64_t>>(wrappers, "L");
    declareImagePca<MaskedImage<int>>(wrappers, "MI");
    declareImagePca<MaskedImage<float>>(wrappers, "MF");
    declareImagePca<MaskedImage<double>>(wrappers, "MD");
    declareImagePca<MaskedImage<std::uint16_t>>(wrappers, "MU");
    declareImagePca<MaskedImage<std::uint64_t>>(wrappers, "ML");
 
    declareInnerProduct<Image<int>, Image<int>>(wrappers);
    declareInnerProduct<Image<float>, Image<float>>(wrappers);
    declareInnerProduct<Image<double>, Image<double>>(wrappers);
    declareInnerProduct<Image<std::uint16_t>, Image<std::uint16_t>>(wrappers);
    declareInnerProduct<Image<std::uint64_t>, Image<std::uint64_t>>(wrappers);
 
    declareInnerProduct<Image<float>, Image<double>>(wrappers);
    declareInnerProduct<Image<double>, Image<float>>(wrappers);
}

wrapImageSlice()

void lsst::afw::image::wrapImageSlice

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 115 of file _imageSlice.cc.

                                                                {
    declareImageSlice<float>(wrappers, "F");
    declareImageSlice<double>(wrappers, "D");
}

wrapImageUtils()

void lsst::afw::image::wrapImageUtils

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 35 of file _imageUtils.cc.

                                                                {
    wrappers.wrap([](auto &mod) {
        mod.def("indexToPosition", indexToPosition);
        mod.def("positionToIndex", (int (*)(double))positionToIndex);
        mod.def("positionToIndex", (std::pair<int, double>(*)(double const, bool))positionToIndex);
    });
}

wrapPhotoCalib()

void lsst::afw::image::wrapPhotoCalib

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 208 of file _photoCalib.cc.

                                                                {
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    declareMeasurement(wrappers);
    declarePhotoCalib(wrappers);
    declareCalib(wrappers);
}

wrapReaders()

void lsst::afw::image::wrapReaders

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 338 of file _readers.cc.

                                                             {
    // wrappers.addInheritanceDependency("lsst.daf.base");
    wrappers.addSignatureDependency("lsst.geom");
    wrappers.addSignatureDependency("lsst.afw.image.image");
    wrappers.addSignatureDependency("lsst.afw.image.maskedImage");
    wrappers.addSignatureDependency("lsst.afw.image.exposure");
    declareImageFitsReader(wrappers);
    declareMaskFitsReader(wrappers);
    declareMaskedImageFitsReader(wrappers);
    declareExposureFitsReader(wrappers);
}

wrapTransmissionCurve()

void lsst::afw::image::wrapTransmissionCurve

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 46 of file _transmissionCurve.cc.

                                                                       {
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    wrappers.addSignatureDependency("lsst.afw.geom");
    wrappers.wrapType(PyTransmissionCurve(wrappers.module, "TransmissionCurve"), [](auto &mod, auto &cls) {
        table::io::python::addPersistableMethods(cls);
 
        cls.def_static("makeIdentity", &TransmissionCurve::makeIdentity);
        cls.def_static("makeSpatiallyConstant", &TransmissionCurve::makeSpatiallyConstant, "throughput"_a,
                       "wavelengths"_a, "throughputAtMin"_a = 0.0, "throughputAtMax"_a = 0.0);
        cls.def_static("makeRadial", &TransmissionCurve::makeRadial, "throughput"_a, "wavelengths"_a,
                       "radii"_a, "throughputAtMin"_a = 0.0, "throughputAtMax"_a = 0.0);
        cls.def("__mul__", &TransmissionCurve::multipliedBy, py::is_operator());
        cls.def("multipliedBy", &TransmissionCurve::multipliedBy);
        cls.def("transformedBy", &TransmissionCurve::transformedBy, "transform"_a);
        cls.def("getWavelengthBounds", &TransmissionCurve::getWavelengthBounds);
        cls.def("getThroughputAtBounds", &TransmissionCurve::getThroughputAtBounds);
        cls.def("sampleAt",
                (void (TransmissionCurve::*)(lsst::geom::Point2D const &,
                                             ndarray::Array<double const, 1, 1> const &,
                                             ndarray::Array<double, 1, 1> const &) const) &
                        TransmissionCurve::sampleAt,
                "position"_a, "wavelengths"_a, "out"_a);
        cls.def("sampleAt",
                (ndarray::Array<double, 1, 1>(TransmissionCurve::*)(
                        lsst::geom::Point2D const &, ndarray::Array<double const, 1, 1> const &) const) &
                        TransmissionCurve::sampleAt,
                "position"_a, "wavelengths"_a);
    });
}

wrapVisitInfo()

void lsst::afw::image::wrapVisitInfo

(

lsst::utils::python::WrapperCollection &

wrappers

)

Definition at line 122 of file _visitInfo.cc.

                                                               {
    wrappers.addInheritanceDependency("lsst.daf.base");
    wrappers.addInheritanceDependency("lsst.geom");
    wrappers.addInheritanceDependency("lsst.afw.coord");
    wrappers.addInheritanceDependency("lsst.afw.typehandling");
    declareRotType(wrappers);
    declareVisitInfo(wrappers);
    wrappers.wrap([](auto &mod) {
        /* Free Functions */
        mod.def("setVisitInfoMetadata", &detail::setVisitInfoMetadata, "metadata"_a, "visitInfo"_a);
        mod.def("stripVisitInfoKeywords", &detail::stripVisitInfoKeywords, "metadata"_a);
    });
}

write()

void lsst::afw::image::write ( OutputArchiveHandle &  handle ) const

overrideprotected

Variable Documentation

final

class Filter lsst::afw::image::final

Initial value:

{
public:
    explicit FilterProperty(std::string const& name, double lambdaEff, double lambdaMin = NAN,
                            double lambdaMax = NAN, bool force = false)
            : _name(name), _lambdaEff(lambdaEff), _lambdaMin(lambdaMin), _lambdaMax(lambdaMax) {
        _insert(force);
    }
    
    explicit FilterProperty(std::string const& name,
                            lsst::daf::base::PropertySet const& prop = lsst::daf::base::PropertySet(),
                            bool force = false)

Describe the properties of a Filter (e.g.

Holds an integer identifier for an LSST filter.

effective wavelength)

Definition at line 53 of file Filter.h.

PixelZeroPos

const double lsst::afw::image::PixelZeroPos = 0.0

position of center of pixel 0

FITS uses 1.0, SDSS uses 0.5, LSST uses 0.0 (http://dev.lsstcorp.org/trac/wiki/BottomLeftPixelProposalII%3A)

Definition at line 44 of file ImageUtils.h.