LSST Applications g2079a07aa2+86d27d4dc4,g2305ad1205+a659bff248,g2bbee38e9b+3c60f8fe34,g337abbeb29+3c60f8fe34,g33d1c0ed96+3c60f8fe34,g3502564af9+d77d6d1350,g3a166c0a6a+3c60f8fe34,g487adcacf7+25d9892218,g4be5004598+d77d6d1350,g50ff169b8f+96c6868917,g52b1c1532d+585e252eca,g591dd9f2cf+4d81263f9a,g5cd07815a0+980d2b1c3b,g607f77f49a+d77d6d1350,g858d7b2824+d77d6d1350,g88963caddf+83e433e629,g99cad8db69+a4d3c48eeb,g9ddcbc5298+9a081db1e4,ga1e77700b3+bcf1af89ad,ga57fefb910+9a39d7b2d7,gae0086650b+585e252eca,gb065fddaf9+4f9fd82a2c,gb0e22166c9+60f28cb32d,gb363559e06+d84b1d3d07,gb3b7280ab2+4563d032e1,gb4b16eec92+babe958938,gba4ed39666+c2a2e4ac27,gbb8dafda3b+ed6854b564,gc120e1dc64+b72d212f87,gc28159a63d+3c60f8fe34,gc3e9b769f7+921dbcd359,gcf0d15dbbd+9a39d7b2d7,gdaeeff99f8+f9a426f77a,gddc38dedce+585e252eca,ge79ae78c31+3c60f8fe34,w.2024.21
LSST Data Management Base Package
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
lsst::afw::image Namespace Reference

Namespaces

namespace  _apCorrMap
 
namespace  _basicUtils
 
namespace  _exposure
 
namespace  _exposureInfoContinued
 
namespace  _exposureSummaryStats
 
namespace  _image
 
namespace  _maskedImage
 
namespace  _photoCalibContinued
 
namespace  _visitInfo
 
namespace  detail
 
namespace  details
 
namespace  exposure
 
namespace  impl
 
namespace  pixel
 
namespace  python
 
namespace  testUtils
 
namespace  utils
 

Classes

class  ApCorrMap
 A thin wrapper around std::map to allow aperture corrections to be attached to Exposures. More...
 
class  CheckIndices
 A class used to request that array accesses be checked. 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...
 
struct  ConstReference
 metafunction to extract const reference type from PixelT More...
 
class  DecoratedImage
 A container for an Image and its associated metadata. 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...
 
struct  GetImage
 
class  Image
 A class to represent a 2-dimensional array of pixels. 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  imageIterator
 An ImageBase iterator. More...
 
class  imageLocator
 An ImageBase locator. 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...
 
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...
 
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...
 
struct  Reference
 metafunction to extract reference type from PixelT 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

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

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.
 
double abMagErrFromFluxErr (double fluxErr, double flux)
 Compute AB magnitude error from flux and flux error in Janskys.
 
double fluxFromABMag (double mag) noexcept
 Compute flux in Janskys from AB magnitude.
 
double fluxErrFromABMagErr (double magErr, double mag) noexcept
 Compute flux error in Janskys from AB magnitude error and AB magnitude.
 
template<typename T >
ndarray::Array< T, 1 > abMagFromFlux (ndarray::Array< T const, 1 > const &flux)
 Compute AB magnitude from flux in Janskys.
 
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.
 
template<typename T >
ndarray::Array< T, 1 > fluxFromABMag (ndarray::Array< T const, 1 > const &mag)
 Compute flux in Janskys from AB magnitude.
 
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.
 
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.
 
std::string getDatabaseFilterLabel (std::string const &filterLabel)
 Remap special characters, etc.
 
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.
 
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.
 
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.
 
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.
 
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)
 
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.
 
template<typename LhsT >
void for_each_pixel (Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
 Set each pixel in an Image<LhsT> to func()
 
template<typename LhsT >
void for_each_pixel (Image< LhsT > &lhs, pixelOp1< LhsT > const &func)
 Set each pixel in an Image<LhsT> to func(lhs)
 
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)
 
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>
 
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>
 
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>
 
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.
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator+ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 Overload operator+()
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator+ (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
 Overload operator+()
 
template<typename PixelT >
void operator+= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 Overload operator+=()
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator- (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 Overload operator-()
 
template<typename PixelT >
void operator-= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 Overload operator-=()
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator* (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 Overload operator*()
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator* (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
 Overload operator*()
 
template<typename PixelT >
void operator*= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 Overload operator*=()
 
template<typename PixelT >
std::shared_ptr< Image< PixelT > > operator/ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 Overload operator/()
 
template<typename PixelT >
void operator/= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 Overload operator/=()
 
double indexToPosition (double ind)
 Convert image index to image position.
 
int positionToIndex (double pos)
 Convert image position to nearest integer index.
 
int positionToIndex (double &residual, double pos)
 Convert image position to index (nearest integer and fractional parts)
 
std::pair< int, double > positionToIndex (double const pos, bool)
 Convert image position to index (nearest integer and fractional parts)
 
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.
 
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.
 
std::ostreamoperator<< (std::ostream &os, Measurement const &measurement)
 
void assertNonNegative (double value, std::string const &name)
 Raise lsst::pex::exceptions::InvalidParameterError if value is not >=0.
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromMetadata (daf::base::PropertySet &metadata, bool strip=false)
 Construct a PhotoCalib from FITS FLUXMAG0/FLUXMAG0ERR keywords.
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromCalibZeroPoint (double instFluxMag0, double instFluxMag0Err)
 Construct a PhotoCalib from the deprecated Calib-style instFluxMag0/instFluxMag0Err values.
 
std::ostreamoperator<< (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)
 
 PYBIND11_MODULE (_exposure, mod)
 
void wrapExposureInfo (lsst::utils::python::WrapperCollection &wrappers)
 
void wrapFilterLabel (lsst::utils::python::WrapperCollection &wrappers)
 
void wrapImage (lsst::utils::python::WrapperCollection &wrappers)
 
void wrapImageSlice (lsst::utils::python::WrapperCollection &)
 
 PYBIND11_MODULE (_imageLib, mod)
 
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 (_maskedImage, mod)
 
void declareVisitInfo (lsst::utils::python::WrapperCollection &wrappers)
 
void declareRotType (lsst::utils::python::WrapperCollection &wrappers)
 
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< FilterLabelmakeFilterLabelDirect (std::string const &name)
 Convert an old-style filter name to a FilterLabel without external information.
 
std::shared_ptr< FilterLabelmakeFilterLabel (std::string const &name)
 Convert an old-style single Filter name to a FilterLabel, using available information.
 
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::ostreamoperator<< (std::ostream &os, PhotoCalib const &photoCalib)
 
bool _eqOrNan (double lhs, double rhs) noexcept
 Test whether two numbers are exactly equal or both NaN.
 
bool _eqOrNonFinite (lsst::geom::SpherePoint const &lhs, lsst::geom::SpherePoint const &rhs) noexcept
 Test whether two SpherePoints are exactly equal or invalid.
 

Variables

const double PixelZeroPos = 0.0
 position of center of pixel 0
 

Typedef Documentation

◆ MaskPixel

default type for Masks and MaskedImage Masks

Definition at line 34 of file LsstImageTypes.h.

◆ PyCoaddInputs

Definition at line 40 of file _coaddInputs.cc.

◆ PyColor

Definition at line 38 of file _color.cc.

◆ PyTransmissionCurve

Initial value:
py::class_<TransmissionCurve, std::shared_ptr<TransmissionCurve>, typehandling::Storable>

Definition at line 43 of file _transmissionCurve.cc.

◆ VariancePixel

default type for MaskedImage variance images

Definition at line 35 of file LsstImageTypes.h.

Enumeration Type Documentation

◆ ImageOrigin

Enumerator
PARENT 
LOCAL 

Definition at line 94 of file ImageBase.h.

94{ PARENT, LOCAL };

◆ RotType

enum class 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.

45 {
46 UNKNOWN,
48 SKY,
51 HORIZON,
54 MOUNT
55};
@ HORIZON
Position angle of focal plane +Y, measured from +Alt through +Az.
@ MOUNT
The position sent to the instrument rotator; the details depend on the rotator.
@ UNKNOWN
Rotation angle is unknown.
@ SKY
Position angle of focal plane +Y, measured from N through E.

◆ xOrY

Enumerator

Definition at line 36 of file ImageUtils.h.

Function Documentation

◆ _eqOrNan()

bool lsst::afw::image::_eqOrNan ( double lhs,
double rhs )
noexcept

Test whether two numbers are exactly equal or both NaN.

This function is exactly equivalent to operator==(double, double), except that NaNs compare equal (NaNs of different values also compare equal).

Definition at line 539 of file VisitInfo.cc.

539{ return (std::isnan(lhs) && std::isnan(rhs)) || lhs == rhs; }
T isnan(T... args)

◆ _eqOrNonFinite()

bool lsst::afw::image::_eqOrNonFinite ( lsst::geom::SpherePoint const & lhs,
lsst::geom::SpherePoint const & rhs )
noexcept

Test whether two SpherePoints are exactly equal or invalid.

This function is needed because SpherePoint::operation== is specifically designed to be ill-behaved when NaN values are involved.

Definition at line 547 of file VisitInfo.cc.

547 {
548 return (!lhs.isFinite() && !rhs.isFinite()) || lhs == rhs;
549}

◆ 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 60 of file Calib.h.

60 {
61 return std::abs(fluxErr / (-0.4 * flux * std::log(10)));
62}
T log(T... args)

◆ 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 51 of file Calib.cc.

52 {
53 if (flux.getNumElements() != fluxErr.getNumElements()) {
54 throw LSST_EXCEPT(pex::exceptions::LengthError, (boost::format("Length mismatch: %d vs %d") %
55 flux.getNumElements() % fluxErr.getNumElements())
56 .str());
57 }
58 ndarray::Array<T, 1> out = ndarray::allocate(flux.getShape());
59 for (std::size_t ii = 0; ii < flux.getNumElements(); ++ii) {
60 out[ii] = abMagErrFromFluxErr(fluxErr[ii], flux[ii]);
61 }
62 return out;
63}
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48
Reports attempts to exceed implementation-defined length limits for some classes.
Definition Runtime.h:76

◆ abMagFromFlux() [1/4]

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

Compute AB magnitude from flux in Janskys.

Definition at line 57 of file Calib.h.

57{ return -2.5 * std::log10(flux / JanskysPerABFlux); }
T log10(T... args)

◆ 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 41 of file Calib.cc.

41 {
42 ndarray::Array<T, 1> out = ndarray::allocate(flux.getShape());
43 for (std::size_t ii = 0; ii < flux.getNumElements(); ++ii) {
44 out[ii] = abMagFromFlux(flux[ii]);
45 }
46 return out;
47}
double abMagFromFlux(double flux)
Compute AB magnitude from flux in Janskys.
Definition Calib.h:57

◆ 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
valueValue that should be positive.
nameText to prepend to error message.
Exceptions
lsst::pex::exceptions::InvalidParameterErrorif value < 0

Definition at line 69 of file PhotoCalib.h.

69 {
70 if (value < 0) {
72 (boost::format("%s must be positive: %.3g") % name % value).str());
73 }
74}
Reports invalid arguments.
Definition Runtime.h:66

◆ 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 681 of file Image.cc.

681 {
683 if (metadata.exists("ZNAXIS1") && metadata.exists("ZNAXIS2")) {
684 dims = lsst::geom::Extent2I(metadata.getAsInt("ZNAXIS1"), metadata.getAsInt("ZNAXIS2"));
685 } else {
686 dims = lsst::geom::Extent2I(metadata.getAsInt("NAXIS1"), metadata.getAsInt("NAXIS2"));
687 }
688 lsst::geom::Point2I xy0 = geom::getImageXY0FromMetadata(metadata, detail::wcsNameForXY0);
689 return lsst::geom::Box2I(xy0, dims);
690}
int getAsInt(std::string const &name) const
Get the last value for a bool/char/short/int property name (possibly hierarchical).
bool exists(std::string const &name) const
Determine if a name (possibly hierarchical) exists.
An integer coordinate rectangle.
Definition Box.h:55
Extent< int, 2 > Extent2I
Definition Extent.h:397

◆ declareRotType()

void lsst::afw::image::declareRotType ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 148 of file _visitInfo.cc.

148 {
149 wrappers.wrapType(py::enum_<RotType>(wrappers.module, "RotType"), [](auto &mod, auto &enm) {
150 enm.value("UNKNOWN", RotType::UNKNOWN);
151 enm.value("SKY", RotType::SKY);
152 enm.value("HORIZON", RotType::HORIZON);
153 enm.value("MOUNT", RotType::MOUNT);
154 enm.export_values();
155 });
156}

◆ declareVisitInfo()

void lsst::afw::image::declareVisitInfo ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 57 of file _visitInfo.cc.

57 {
58 wrappers.wrapType(
60 "VisitInfo"),
61 [](auto &mod, auto &cls) {
62 /* Constructors */
63 cls.def(py::init<double, double, daf::base::DateTime const &, double,
64 lsst::geom::Angle const &, lsst::geom::SpherePoint const &,
65 lsst::geom::SpherePoint const &, double, lsst::geom::Angle const &,
66 RotType const &, coord::Observatory const &, coord::Weather const &,
67 std::string const &, table::RecordId const &, double, std::string const &,
68 std::string const &, std::string const &, std::string const &, bool>(),
69 "exposureTime"_a = nan, "darkTime"_a = nan, "date"_a = daf::base::DateTime(),
70 "ut1"_a = nan, "era"_a = nanAngle,
71 "boresightRaDec"_a = lsst::geom::SpherePoint(nanAngle, nanAngle),
72 "boresightAzAlt"_a = lsst::geom::SpherePoint(nanAngle, nanAngle),
73 "boresightAirmass"_a = nan, "boresightRotAngle"_a = nanAngle,
74 "rotType"_a = RotType::UNKNOWN,
75 "observatory"_a = coord::Observatory(nanAngle, nanAngle, nan),
76 "weather"_a = coord::Weather(nan, nan, nan), "instrumentLabel"_a = "", "id"_a = 0,
77 "focusZ"_a = nan, "observationType"_a = "", "scienceProgram"_a = "",
78 // default hasSimulatedContent=false for backwards compatibility
79 "observationReason"_a = "", "object"_a = "", "hasSimulatedContent"_a = false);
80 cls.def(py::init<daf::base::PropertySet const &>(), "metadata"_a);
81 cls.def(py::init<VisitInfo const &>(), "visitInfo"_a);
82
83 table::io::python::addPersistableMethods<VisitInfo>(cls);
84
85 /* Operators */
86 cls.def(
87 "__eq__", [](VisitInfo const &self, VisitInfo const &other) { return self == other; },
88 py::is_operator());
89 cls.def(
90 "__ne__", [](VisitInfo const &self, VisitInfo const &other) { return self != other; },
91 py::is_operator());
92
93 /* Members */
94 cls.def("getExposureTime", &VisitInfo::getExposureTime);
95 cls.def("getDarkTime", &VisitInfo::getDarkTime);
96 cls.def("getDate", &VisitInfo::getDate);
97 cls.def("getUt1", &VisitInfo::getUt1);
98 cls.def("getEra", &VisitInfo::getEra);
99 cls.def("getBoresightRaDec", &VisitInfo::getBoresightRaDec);
100 cls.def("getBoresightAzAlt", &VisitInfo::getBoresightAzAlt);
101 cls.def("getBoresightAirmass", &VisitInfo::getBoresightAirmass);
102 cls.def("getBoresightParAngle", &VisitInfo::getBoresightParAngle);
103 cls.def("getBoresightRotAngle", &VisitInfo::getBoresightRotAngle);
104 cls.def("getRotType", &VisitInfo::getRotType);
105 cls.def("getObservatory", &VisitInfo::getObservatory);
106 cls.def("getWeather", &VisitInfo::getWeather);
107 cls.def("isPersistable", &VisitInfo::isPersistable);
108 cls.def("getLocalEra", &VisitInfo::getLocalEra);
109 cls.def("getBoresightHourAngle", &VisitInfo::getBoresightHourAngle);
110 cls.def("getInstrumentLabel", &VisitInfo::getInstrumentLabel);
111 cls.def("getId", &VisitInfo::getId);
112 cls.def("getFocusZ", &VisitInfo::getFocusZ);
113 cls.def("getObservationType", &VisitInfo::getObservationType);
114 cls.def("getScienceProgram", &VisitInfo::getScienceProgram);
115 cls.def("getObservationReason", &VisitInfo::getObservationReason);
116 cls.def("getObject", &VisitInfo::getObject);
117 cls.def("getHasSimulatedContent", &VisitInfo::getHasSimulatedContent);
118
119 /* readonly property accessors */
120 cls.def_property_readonly("exposureTime", &VisitInfo::getExposureTime);
121 cls.def_property_readonly("darkTime", &VisitInfo::getDarkTime);
122 cls.def_property_readonly("date", &VisitInfo::getDate);
123 cls.def_property_readonly("ut1", &VisitInfo::getUt1);
124 cls.def_property_readonly("era", &VisitInfo::getEra);
125 cls.def_property_readonly("boresightRaDec", &VisitInfo::getBoresightRaDec);
126 cls.def_property_readonly("boresightAzAlt", &VisitInfo::getBoresightAzAlt);
127 cls.def_property_readonly("boresightAirmass", &VisitInfo::getBoresightAirmass);
128 cls.def_property_readonly("boresightParAngle", &VisitInfo::getBoresightParAngle);
129 cls.def_property_readonly("boresightRotAngle", &VisitInfo::getBoresightRotAngle);
130 cls.def_property_readonly("rotType", &VisitInfo::getRotType);
131 cls.def_property_readonly("observatory", &VisitInfo::getObservatory);
132 cls.def_property_readonly("weather", &VisitInfo::getWeather);
133 cls.def_property_readonly("isPersistable", &VisitInfo::isPersistable);
134 cls.def_property_readonly("localEra", &VisitInfo::getLocalEra);
135 cls.def_property_readonly("boresightHourAngle", &VisitInfo::getBoresightHourAngle);
136 cls.def_property_readonly("instrumentLabel", &VisitInfo::getInstrumentLabel);
137 cls.def_property_readonly("id", &VisitInfo::getId);
138 cls.def_property_readonly("focusZ", &VisitInfo::getFocusZ);
139 cls.def_property_readonly("observationType", &VisitInfo::getObservationType);
140 cls.def_property_readonly("scienceProgram", &VisitInfo::getScienceProgram);
141 cls.def_property_readonly("observationReason", &VisitInfo::getObservationReason);
142 cls.def_property_readonly("object", &VisitInfo::getObject);
143 cls.def_property_readonly("hasSimulatedContent", &VisitInfo::getHasSimulatedContent);
144
145 utils::python::addOutputOp(cls, "__repr__");
146 });
147}
Information about a single exposure of an imaging camera.
Definition VisitInfo.h:68
Interface supporting iteration over heterogenous containers.
Definition Storable.h:58

◆ 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 68 of file Calib.h.

68 {
69 return std::abs(-0.4 * magErr * fluxFromABMag(mag) * std::log(10.0));
70}
double fluxFromABMag(double mag) noexcept
Compute flux in Janskys from AB magnitude.
Definition Calib.h:65

◆ 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 77 of file Calib.cc.

78 {
79 if (mag.getNumElements() != magErr.getNumElements()) {
80 throw LSST_EXCEPT(pex::exceptions::LengthError, (boost::format("Length mismatch: %d vs %d") %
81 mag.getNumElements() % magErr.getNumElements())
82 .str());
83 }
84 ndarray::Array<T, 1> out = ndarray::allocate(mag.getShape());
85 for (std::size_t ii = 0; ii < mag.getNumElements(); ++ii) {
86 out[ii] = fluxErrFromABMagErr(magErr[ii], mag[ii]);
87 }
88 return out;
89}

◆ fluxFromABMag() [1/4]

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

Compute flux in Janskys from AB magnitude.

Definition at line 65 of file Calib.h.

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

◆ 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 67 of file Calib.cc.

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

◆ 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
lhsImage to set
rhsother Image to pass to func
funcfunctor to call

Definition at line 142 of file ImageAlgorithm.h.

145 {
146 if (lhs.getDimensions() != rhs.getDimensions()) {
148 (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
149 lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
150 .str());
151 }
152
153 for (int y = 0; y != lhs.getHeight(); ++y) {
154 typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
155
156 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
157 lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
158 *lhsPtr = func(*rhsPtr);
159 }
160 }
161}
int y
Definition SpanSet.cc:48
int getWidth() const
Return the number of columns in the image.
Definition ImageBase.h:294
lsst::geom::Extent2I getDimensions() const
Return the image's size; useful for passing to constructors.
Definition ImageBase.h:356
int getHeight() const
Return the number of rows in the image.
Definition ImageBase.h:296
x_iterator row_begin(int y) const
Return an x_iterator to the start of the y'th row.
Definition ImageBase.h:401
x_iterator row_end(int y) const
Return an x_iterator to the end of the y'th row.
Definition ImageBase.h:404

◆ 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
lhsImage to set
rhsother Image to pass to func
funcfunctor to call

Definition at line 167 of file ImageAlgorithm.h.

170 {
171 if (lhs.getDimensions() != rhs.getDimensions()) {
173 (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
174 lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
175 .str());
176 }
177
178 for (int y = 0; y != lhs.getHeight(); ++y) {
179 typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
180
181 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
182 lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
183 *lhsPtr = func(*lhsPtr, *rhsPtr);
184 }
185 }
186}

◆ 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
lhsImage to set
rhsother Image to pass to func
funcfunctor to call

Definition at line 193 of file ImageAlgorithm.h.

196 {
197 if (lhs.getDimensions() != rhs.getDimensions()) {
199 (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
200 lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
201 .str());
202 }
203
204 for (int y = 0; y != lhs.getHeight(); ++y) {
205 typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
206 int x = lhs.getX0();
207 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
208 lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
209 *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
210 }
211 }
212}
int getX0() const
Return the image's column-origin.
Definition ImageBase.h:306
int getY0() const
Return the image's row-origin.
Definition ImageBase.h:314

◆ 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
lhsImage to set
funcfunctor to call

Definition at line 94 of file ImageAlgorithm.h.

96 {
97 for (int y = 0; y != lhs.getHeight(); ++y) {
98 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
99 lhsPtr != lhsEnd; ++lhsPtr) {
100 *lhsPtr = func();
101 }
102 }
103}
typename _view_t::x_iterator x_iterator
An iterator for traversing the pixels in a row.
Definition ImageBase.h:133

◆ 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
lhsImage to set
funcfunctor to call

Definition at line 109 of file ImageAlgorithm.h.

111 {
112 for (int y = 0; y != lhs.getHeight(); ++y) {
113 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
114 lhsPtr != lhsEnd; ++lhsPtr) {
115 *lhsPtr = func(*lhsPtr);
116 }
117 }
118}

◆ 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
lhsImage to set
funcfunctor to call

Definition at line 126 of file ImageAlgorithm.h.

128 {
129 for (int y = 0; y != lhs.getHeight(); ++y) {
130 int x = lhs.getX0();
131 for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
132 lhsPtr != lhsEnd; ++lhsPtr, ++x) {
133 *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr);
134 }
135 }
136}

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

45 {
46 static std::regex const unsafeCharacters("\\W"s);
47 return std::regex_replace(filterLabel, unsafeCharacters, "_"s);
48}
T regex_replace(T... args)

◆ 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 693 of file Image.cc.

693 {
694
695 if (image1.getArea() == 0 || image2.getArea() == 0) {
696 // zero-area images cannot overlap.
697 return false;
698 }
699
700 auto arr1 = image1.getArray();
701 // get the address of the first and one-past-the-last element of arr1 using ndarray iterators;
702 // this works because the iterators for contiguous 1-d ndarray Arrays are just pointers
703 auto beg1Addr = arr1.front().begin();
704 auto end1Addr = arr1.back().end();
705
706 auto arr2 = image2.getArray();
707 auto beg2Addr = arr2.front().begin();
708 auto end2Addr = arr2.back().end();
709
710 auto ptrLess = std::less<void const* const>();
711 return ptrLess(beg1Addr, end2Addr) && ptrLess(beg2Addr, end1Addr);
712}
int getArea() const
Return the area of the image.
Definition ImageBase.h:298

◆ 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 680 of file MaskedImage.cc.

681 {
682 return imagesOverlap(*image1.getImage(), *image2.getImage()) ||
683 imagesOverlap(*image1.getVariance(), *image2.getVariance()) ||
684 imagesOverlap(*image1.getMask(), *image2.getMask());
685}
VariancePtr getVariance() const
Return a (shared_ptr to) the MaskedImage's variance.
MaskPtr getMask() const
Return a (shared_ptr to) the MaskedImage's mask.
ImagePtr getImage() const
Return a (shared_ptr to) the MaskedImage's image.
bool imagesOverlap(ImageBase< T1 > const &image1, ImageBase< T2 > const &image2)
Return true if the pixels for two images or masks overlap in memory.
Definition Image.cc:693

◆ 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 >()

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

◆ 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 >()

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

◆ 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
indimage index

Definition at line 55 of file ImageUtils.h.

56 {
57 return ind + PixelZeroPos;
58}
const double PixelZeroPos
position of center of pixel 0
Definition ImageUtils.h:44

◆ 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
lhsfirst image
rhsOther image to dot with first
bordernumber of pixels to ignore around the edge
Returns
The inner product
Exceptions
lsst::pex::exceptions::LengthErrorif all the images aren't the same size

Definition at line 413 of file ImagePca.cc.

413 {
414 if (lhs.getWidth() <= 2 * border || lhs.getHeight() <= 2 * border) {
416 (boost::format("All image pixels are in the border of width %d: %dx%d") % border %
417 lhs.getWidth() % lhs.getHeight())
418 .str());
419 }
420
421 double sum = 0.0;
422 //
423 // Handle I.I specially for efficiency, and to avoid advancing the iterator twice
424 //
425 if (imagesAreIdentical(lhs, rhs)) {
426 for (int y = border; y != lhs.getHeight() - border; ++y) {
427 for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
428 lend = lhs.row_end(y) - border;
429 lptr != lend; ++lptr) {
430 typename Image1T::Pixel val = *lptr;
431 if (std::isfinite(val)) {
432 sum += val * val;
433 }
434 }
435 }
436 } else {
437 if (lhs.getDimensions() != rhs.getDimensions()) {
439 (boost::format("Dimension mismatch: %dx%d v. %dx%d") % lhs.getWidth() %
440 lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
441 .str());
442 }
443
444 for (int y = border; y != lhs.getHeight() - border; ++y) {
445 typename Image2T::const_x_iterator rptr = rhs.row_begin(y) + border;
446 for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
447 lend = lhs.row_end(y) - border;
448 lptr != lend; ++lptr, ++rptr) {
449 double const tmp = (*lptr) * (*rptr);
450 if (std::isfinite(tmp)) {
451 sum += tmp;
452 }
453 }
454 }
455 }
456
457 return sum;
458}
T isfinite(T... args)
ImageT val
Definition CR.cc:146

◆ 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
mimagethe Exposure's image
wcsthe Exposure's WCS

Definition at line 484 of file Exposure.h.

488 {
491}
A class to contain the data, WCS, and other information needed to describe an image of the sky.
Definition Exposure.h:72

◆ makeFilterLabel()

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.

Parameters
nameThe 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 117 of file ExposureFitsReader.cc.

117 {
118 if (_AFW_NAMES.count(name) > 0) {
119 return std::make_shared<FilterLabel>(_AFW_NAMES.at(name));
120 }
121 // else name is either a band, a physical filter, or a deprecated alias
122
123 // Unknown filter, no extra info to be gained
124 return makeFilterLabelDirect(name);
125}

◆ 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
nameA name for the filter.
Returns
A FilterLabel containing that name.

Definition at line 95 of file ExposureFitsReader.cc.

95 {
96 static std::string const DEFAULT = "_unknown_";
97 // Avoid turning dummy filters into real FilterLabels.
98 if (name == DEFAULT) {
99 return nullptr;
100 }
101
102 // FilterLabel::from* returns a statically allocated object, so only way
103 // to get it into shared_ptr is to copy it.
104 if (_isBand(name)) {
105 return std::make_shared<FilterLabel>(FilterLabel::fromBand(name));
106 } else {
107 return std::make_shared<FilterLabel>(FilterLabel::fromPhysical(name));
108 }
109}

◆ 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
imageimage
maskmask
variancevariance

Definition at line 1241 of file MaskedImage.h.

1245 {
1247}
afw::table::Key< afw::table::Array< MaskPixelT > > mask
afw::table::Key< afw::table::Array< VariancePixelT > > variance
A class to manipulate images, masks, and variance as a single object.
Definition MaskedImage.h:74

◆ 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
instFluxMag0The instrumental flux at zero magnitude. If 0, the resulting PhotoCalib will have infinite calibrationMean and non-finite (inf or NaN) calibrationErr.
instFluxMag0ErrThe 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.

614 {
615 double calibration = utils::referenceFlux / instFluxMag0;
616 double calibrationErr = utils::referenceFlux * instFluxMag0Err / std::pow(instFluxMag0, 2);
617 return std::make_shared<PhotoCalib>(calibration, calibrationErr);
618}
table::Key< double > 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
metadataFITS header metadata containing FLUXMAG0 and FLUXMAG0ERR keys.
stripStrip 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.

596 {
597 auto key = "FLUXMAG0";
598 if (metadata.exists(key)) {
599 double instFluxMag0 = metadata.getAsDouble(key);
600 if (strip) metadata.remove(key);
601
602 double instFluxMag0Err = 0.0;
603 key = "FLUXMAG0ERR";
604 if (metadata.exists(key)) {
605 instFluxMag0Err = metadata.getAsDouble(key);
606 if (strip) metadata.remove(key);
607 }
608 return makePhotoCalibFromCalibZeroPoint(instFluxMag0, instFluxMag0Err);
609 } else {
610 return nullptr;
611 }
612}
virtual void remove(std::string const &name)
Remove all values for a property name (possibly hierarchical).
double getAsDouble(std::string const &name) const
Get the last value for any arithmetic property name (possibly hierarchical).
bool strip
Definition fits.cc:930

◆ 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
imgThe Image
slcThe ImageSlice

Definition at line 104 of file ImageSlice.cc.

104 {
105 std::shared_ptr<Image<PixelT>> retImg(new Image<PixelT>(img, true));
106 *retImg *= slc;
107 return retImg;
108}
A class to represent a 2-dimensional array of pixels.
Definition Image.h:51

◆ 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
slcThe Image
imgThe ImageSlice

Definition at line 111 of file ImageSlice.cc.

111 {
112 return operator*(img, slc);
113}
std::shared_ptr< Image< PixelT > > operator*(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator*()

◆ 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 670 of file Image.cc.

670 {
671 for_each_pixel(lhs, rhs, timesEq<LhsPixelT, RhsPixelT>());
672 return lhs;
673}
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()

◆ 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]imgThe Image
[in]slcThe ImageSlice

Definition at line 116 of file ImageSlice.cc.

116 {
117 details::operate<details::Mult<PixelT>>(img, slc, slc.getImageSliceType());
118}
ImageSliceType getImageSliceType() const
Definition ImageSlice.h:57

◆ 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
imgThe Image
slcThe ImageSlice

Definition at line 69 of file ImageSlice.cc.

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

◆ 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
slcThe ImageSlice
imgThe 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.

76 {
77 return operator+(img, slc);
78}
std::shared_ptr< Image< PixelT > > operator+(Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
Overload operator+()
Definition ImageSlice.cc:69

◆ 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 658 of file Image.cc.

658 {
659 for_each_pixel(lhs, rhs, plusEq<LhsPixelT, RhsPixelT>());
660 return lhs;
661}

◆ 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]imgThe Image
[in]slcThe ImageSlice

Definition at line 81 of file ImageSlice.cc.

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

◆ 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
imgThe Image
slcThe ImageSlice

Definition at line 89 of file ImageSlice.cc.

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

◆ 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 664 of file Image.cc.

664 {
665 for_each_pixel(lhs, rhs, minusEq<LhsPixelT, RhsPixelT>());
666 return lhs;
667}

◆ 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]imgThe Image
[in]slcThe ImageSlice

Definition at line 96 of file ImageSlice.cc.

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

◆ 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
imgThe Image
slcThe ImageSlice

Definition at line 123 of file ImageSlice.cc.

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

◆ 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 676 of file Image.cc.

676 {
677 for_each_pixel(lhs, rhs, divideEq<LhsPixelT, RhsPixelT>());
678 return lhs;
679}

◆ 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]imgThe Image
[in]slcThe ImageSlice

Definition at line 130 of file ImageSlice.cc.

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

◆ operator<<() [1/3]

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

Definition at line 48 of file PhotoCalib.cc.

48 {
51 s << "value=" << measurement.value << ", error=" << measurement.error;
52 return os << s.str();
53}
T setprecision(T... args)

◆ operator<<() [2/3]

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

Definition at line 257 of file PhotoCalib.cc.

257 {
258 return os << photoCalib.toString();
259}

◆ operator<<() [3/3]

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

Definition at line 666 of file VisitInfo.cc.

666 {
667 os << visitInfo.toString();
668 return os;
669}
std::ostream * os
Definition Schema.cc:557
Key< int > visitInfo
Definition Exposure.cc:70

◆ 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
residualfractional part of index
posimage position

Definition at line 85 of file ImageUtils.h.

87 {
88 double fullIndex = pos - PixelZeroPos;
89 double roundedIndex = std::floor(fullIndex + 0.5);
90 residual = fullIndex - roundedIndex;
91 return static_cast<int>(roundedIndex);
92}
T floor(T... args)

◆ 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
posimage position

Definition at line 98 of file ImageUtils.h.

100 {
101 double residual; // fractional part of index
102 int const ind = positionToIndex(residual, pos); // integral part
103
104 return std::pair<int, double>(ind, residual);
105}
int positionToIndex(double pos)
Convert image position to nearest integer index.
Definition ImageUtils.h:69

◆ 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
posimage position

Definition at line 69 of file ImageUtils.h.

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

◆ PYBIND11_MODULE() [1/3]

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

Definition at line 194 of file _exposure.cc.

194 {
195 lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image._exposure");
196 wrappers.addSignatureDependency("lsst.afw.image._apCorrMap");
197 wrappers.addSignatureDependency("lsst.afw.geom");
198 wrappers.addSignatureDependency("lsst.afw.detection");
199 wrappers.addSignatureDependency("lsst.afw.image._maskedImage");
200
201 auto clsExposureF = declareExposure<float>(wrappers, "F");
202 auto clsExposureD = declareExposure<double>(wrappers, "D");
203 declareExposure<int>(wrappers, "I");
204 declareExposure<std::uint16_t>(wrappers, "U");
205 declareExposure<std::uint64_t>(wrappers, "L");
206
207 // Declare constructors for casting all exposure types to to float and double
208 // (the only two types of casts that Python supports)
209 declareCastConstructor<int, float>(clsExposureF);
210 declareCastConstructor<int, double>(clsExposureD);
211
212 declareCastConstructor<float, double>(clsExposureD);
213 declareCastConstructor<double, float>(clsExposureF);
214
215 declareCastConstructor<std::uint16_t, float>(clsExposureF);
216 declareCastConstructor<std::uint16_t, double>(clsExposureD);
217
218 declareCastConstructor<std::uint64_t, float>(clsExposureF);
219 declareCastConstructor<std::uint64_t, double>(clsExposureD);
220
221 wrappers.finish();
222}

◆ PYBIND11_MODULE() [2/3]

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

Definition at line 34 of file _imageLib.cc.

34 {
35 lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image._image");
36 wrapImage(wrappers);
37 wrapImageSlice(wrappers);
38 wrappers.finish();
39}
void wrapImage(lsst::utils::python::WrapperCollection &wrappers)
Definition _image.cc:448
void wrapImageSlice(lsst::utils::python::WrapperCollection &)

◆ PYBIND11_MODULE() [3/3]

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

Definition at line 244 of file _maskedImage.cc.

244 {
245 lsst::utils::python::WrapperCollection wrappers(mod, "lsst.afw.image._maskedImage");
246 wrappers.addSignatureDependency("lsst.afw.image._image");
247 wrappers.addInheritanceDependency("lsst.daf.base");
248
249 auto clsMaskedImageF = declareMaskedImage<float>(wrappers, "F");
250 auto clsMaskedImageD = declareMaskedImage<double>(wrappers, "D");
251 auto clsMaskedImageI = declareMaskedImage<int>(wrappers, "I");
252 auto clsMaskedImageU = declareMaskedImage<std::uint16_t>(wrappers, "U");
253 auto clsMaskedImageL = declareMaskedImage<std::uint64_t>(wrappers, "L");
254
255 // Declare constructors for casting all exposure types to to float and double
256 // (the only two types of casts that Python supports)
257 declareCastConstructor<int, float>(clsMaskedImageF);
258 declareCastConstructor<int, double>(clsMaskedImageD);
259 declareCastConstructor<float, double>(clsMaskedImageD);
260 declareCastConstructor<double, float>(clsMaskedImageF);
261 declareCastConstructor<std::uint16_t, float>(clsMaskedImageF);
262 declareCastConstructor<std::uint16_t, double>(clsMaskedImageD);
263 declareCastConstructor<std::uint64_t, float>(clsMaskedImageF);
264 declareCastConstructor<std::uint64_t, double>(clsMaskedImageD);
265
266 /* Module level */
267 declareMakeMaskedImage<int>(wrappers);
268 declareMakeMaskedImage<float>(wrappers);
269 declareMakeMaskedImage<double>(wrappers);
270 declareMakeMaskedImage<std::uint16_t>(wrappers);
271 declareMakeMaskedImage<std::uint64_t>(wrappers);
272
273 declareImagesOverlap<int, int>(wrappers);
274 declareImagesOverlap<int, float>(wrappers);
275 declareImagesOverlap<int, double>(wrappers);
276 declareImagesOverlap<int, std::uint16_t>(wrappers);
277 declareImagesOverlap<int, std::uint64_t>(wrappers);
278
279 declareImagesOverlap<float, int>(wrappers);
280 declareImagesOverlap<float, float>(wrappers);
281 declareImagesOverlap<float, double>(wrappers);
282 declareImagesOverlap<float, std::uint16_t>(wrappers);
283 declareImagesOverlap<float, std::uint64_t>(wrappers);
284
285 declareImagesOverlap<double, int>(wrappers);
286 declareImagesOverlap<double, float>(wrappers);
287 declareImagesOverlap<double, double>(wrappers);
288 declareImagesOverlap<double, std::uint16_t>(wrappers);
289 declareImagesOverlap<double, std::uint64_t>(wrappers);
290
291 declareImagesOverlap<std::uint16_t, int>(wrappers);
292 declareImagesOverlap<std::uint16_t, float>(wrappers);
293 declareImagesOverlap<std::uint16_t, double>(wrappers);
294 declareImagesOverlap<std::uint16_t, std::uint16_t>(wrappers);
295 declareImagesOverlap<std::uint16_t, std::uint64_t>(wrappers);
296
297 declareImagesOverlap<std::uint64_t, int>(wrappers);
298 declareImagesOverlap<std::uint64_t, float>(wrappers);
299 declareImagesOverlap<std::uint64_t, double>(wrappers);
300 declareImagesOverlap<std::uint64_t, std::uint16_t>(wrappers);
301 declareImagesOverlap<std::uint64_t, std::uint64_t>(wrappers);
302 wrappers.finish();
303}

◆ swap() [1/4]

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

Definition at line 78 of file DecoratedImage.cc.

78 {
79 a.swap(b);
80}
table::Key< int > b

◆ swap() [2/4]

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

Definition at line 443 of file Image.cc.

443 {
444 a.swap(b);
445}

◆ swap() [3/4]

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

Definition at line 242 of file Image.cc.

242 {
243 a.swap(b);
244}

◆ swap() [4/4]

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

Definition at line 134 of file Mask.cc.

134 {
135 a.swap(b);
136}

◆ wrapCalib()

void lsst::afw::image::wrapCalib ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 69 of file _calib.cc.

69 {
70 /* Module level */
71 declareCalib(wrappers);
72 declareVectorOperations<float>(wrappers);
73 declareVectorOperations<double>(wrappers);
74}

◆ wrapCoaddInputs()

void lsst::afw::image::wrapCoaddInputs ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 42 of file _coaddInputs.cc.

42 {
43 wrappers.addInheritanceDependency("lsst.afw.typehandling");
44 wrappers.wrapType(PyCoaddInputs(wrappers.module, "CoaddInputs"), [](auto &mod, auto &cls) {
45 /* Constructors */
46 cls.def(py::init<>());
47 cls.def(py::init<table::Schema const &, table::Schema const &>(), "visitSchema"_a, "ccdSchema"_a);
48 cls.def(py::init<table::ExposureCatalog const &, table::ExposureCatalog const &>(), "visits"_a,
49 "ccds"_a);
50
51 table::io::python::addPersistableMethods<CoaddInputs>(cls);
52
53 /* Members */
54 cls.def_readwrite("visits", &CoaddInputs::visits);
55 cls.def_readwrite("ccds", &CoaddInputs::ccds);
56 cls.def("isPersistable", &CoaddInputs::isPersistable);
57 });
58}
py::class_< CoaddInputs, std::shared_ptr< CoaddInputs >, typehandling::Storable > PyCoaddInputs

◆ wrapColor()

void lsst::afw::image::wrapColor ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 40 of file _color.cc.

40 {
41 /* Module level */
42 wrappers.wrapType(PyColor(wrappers.module, "Color"), [](auto &mod, auto &cls) {
43 /* Constructors */
44 cls.def(py::init<double>(), "g_r"_a = std::numeric_limits<double>::quiet_NaN());
45
46 /* Operators */
47 cls.def(
48 "__eq__", [](Color const &self, Color const &other) { return self == other; },
49 py::is_operator());
50 cls.def(
51 "__ne__", [](Color const &self, Color const &other) { return self != other; },
52 py::is_operator());
53
54 /* Members */
55 cls.def("isIndeterminate", &Color::isIndeterminate);
56 });
57}
Describe the colour of a source.
Definition Color.h:25
py::class_< Color, std::shared_ptr< Color > > PyColor
Definition _color.cc:38

◆ wrapDefect()

void lsst::afw::image::wrapDefect ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 56 of file _defect.cc.

56 {
57 wrappers.addSignatureDependency("lsst.afw.geom");
58 declareDefects(wrappers);
59}

◆ wrapExposure()

void lsst::afw::image::wrapExposure ( lsst::utils::python::WrapperCollection & )

◆ wrapExposureInfo()

void lsst::afw::image::wrapExposureInfo ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 224 of file _exposureInfo.cc.

224 {
225 wrappers.addSignatureDependency("lsst.daf.base");
226 wrappers.addSignatureDependency("lsst.afw.geom");
227 wrappers.addSignatureDependency("lsst.afw.cameraGeom");
228 wrappers.addSignatureDependency("lsst.afw.detection"); // For Psf
229 declareExposureInfo(wrappers);
230}

◆ wrapFilterLabel()

void lsst::afw::image::wrapFilterLabel ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 116 of file _filterLabel.cc.

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

◆ wrapImage()

void lsst::afw::image::wrapImage ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 448 of file _image.cc.

448 {
449 wrappers.addSignatureDependency("lsst.daf.base");
450 wrappers.addSignatureDependency("lsst.geom");
451 wrappers.wrapType(py::enum_<ImageOrigin>(wrappers.module, "ImageOrigin"), [](auto &mod, auto &enm) {
452 enm.value("PARENT", ImageOrigin::PARENT);
453 enm.value("LOCAL", ImageOrigin::LOCAL);
454 enm.export_values();
455 });
456
457 declareImageBase<int>(wrappers, "I");
458 declareImageBase<float>(wrappers, "F");
459 declareImageBase<double>(wrappers, "D");
460 declareImageBase<std::uint16_t>(wrappers, "U");
461 declareImageBase<std::uint64_t>(wrappers, "L");
462
463 // Mask must be declared before Image because a mask is used as a default value in at least one method
464 declareMask<MaskPixel>(wrappers, "X");
465
466 auto clsImageI = declareImage<int>(wrappers, "I");
467 auto clsImageF = declareImage<float>(wrappers, "F");
468 auto clsImageD = declareImage<double>(wrappers, "D");
469 auto clsImageU = declareImage<std::uint16_t>(wrappers, "U");
470 auto clsImageL = declareImage<std::uint64_t>(wrappers, "L");
471
472 // Add generalized copy constructors
473 addGeneralizedCopyConstructors<int>(clsImageI);
474 addGeneralizedCopyConstructors<float>(clsImageF);
475 addGeneralizedCopyConstructors<double>(clsImageD);
476 addGeneralizedCopyConstructors<std::uint16_t>(clsImageU);
477 addGeneralizedCopyConstructors<std::uint64_t>(clsImageL);
478
479 // Add slice operators only for float and double
480 addImageSliceOperators<float>(clsImageF);
481 addImageSliceOperators<double>(clsImageD);
482
483 declareDecoratedImage<int>(wrappers, "I");
484 declareDecoratedImage<float>(wrappers, "F");
485 declareDecoratedImage<double>(wrappers, "D");
486 declareDecoratedImage<std::uint16_t>(wrappers, "U");
487 declareDecoratedImage<std::uint64_t>(wrappers, "L");
488
489 // Declare constructors for casting all exposure types to to float and double
490 // (the only two types of casts that Python supports)
491 declareCastConstructor<int, float>(clsImageF);
492 declareCastConstructor<int, double>(clsImageD);
493
494 declareCastConstructor<float, double>(clsImageD);
495
496 declareCastConstructor<double, float>(clsImageF);
497
498 declareCastConstructor<std::uint16_t, float>(clsImageF);
499 declareCastConstructor<std::uint16_t, double>(clsImageD);
500
501 declareCastConstructor<std::uint64_t, float>(clsImageF);
502 declareCastConstructor<std::uint64_t, double>(clsImageD);
503
504 // Note: wrap both the Image and MaskedImage versions of imagesOverlap in the MaskedImage wrapper,
505 // as wrapping the Image version here results in it being invisible in lsst.afw.image
506 wrappers.wrap([](auto &mod) { mod.def("bboxFromMetadata", &bboxFromMetadata); });
507}

◆ wrapImagePca()

void lsst::afw::image::wrapImagePca ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 73 of file _imagePca.cc.

73 {
74 declareImagePca<Image<int>>(wrappers, "I");
75 declareImagePca<Image<float>>(wrappers, "F");
76 declareImagePca<Image<double>>(wrappers, "D");
77 declareImagePca<Image<std::uint16_t>>(wrappers, "U");
78 declareImagePca<Image<std::uint64_t>>(wrappers, "L");
79 declareImagePca<MaskedImage<int>>(wrappers, "MI");
80 declareImagePca<MaskedImage<float>>(wrappers, "MF");
81 declareImagePca<MaskedImage<double>>(wrappers, "MD");
82 declareImagePca<MaskedImage<std::uint16_t>>(wrappers, "MU");
83 declareImagePca<MaskedImage<std::uint64_t>>(wrappers, "ML");
84
85 declareInnerProduct<Image<int>, Image<int>>(wrappers);
86 declareInnerProduct<Image<float>, Image<float>>(wrappers);
87 declareInnerProduct<Image<double>, Image<double>>(wrappers);
88 declareInnerProduct<Image<std::uint16_t>, Image<std::uint16_t>>(wrappers);
89 declareInnerProduct<Image<std::uint64_t>, Image<std::uint64_t>>(wrappers);
90
91 declareInnerProduct<Image<float>, Image<double>>(wrappers);
92 declareInnerProduct<Image<double>, Image<float>>(wrappers);
93}

◆ wrapImageSlice()

void lsst::afw::image::wrapImageSlice ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 115 of file _imageSlice.cc.

115 {
116 declareImageSlice<float>(wrappers, "F");
117 declareImageSlice<double>(wrappers, "D");
118}

◆ wrapImageUtils()

void lsst::afw::image::wrapImageUtils ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 35 of file _imageUtils.cc.

35 {
36 wrappers.wrap([](auto &mod) {
37 mod.def("indexToPosition", indexToPosition);
38 mod.def("positionToIndex", (int (*)(double))positionToIndex);
39 mod.def("positionToIndex", (std::pair<int, double>(*)(double const, bool))positionToIndex);
40 });
41}
double indexToPosition(double ind)
Convert image index to image position.
Definition ImageUtils.h:55

◆ wrapPhotoCalib()

void lsst::afw::image::wrapPhotoCalib ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 209 of file _photoCalib.cc.

209 {
210 wrappers.addInheritanceDependency("lsst.afw.typehandling");
211 declareMeasurement(wrappers);
212 declarePhotoCalib(wrappers);
213 declareCalib(wrappers);
214}

◆ wrapReaders()

void lsst::afw::image::wrapReaders ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 338 of file _readers.cc.

338 {
339 // wrappers.addInheritanceDependency("lsst.daf.base");
340 wrappers.addSignatureDependency("lsst.geom");
341 wrappers.addSignatureDependency("lsst.afw.image._image");
342 wrappers.addSignatureDependency("lsst.afw.image._maskedImage");
343 wrappers.addSignatureDependency("lsst.afw.image._exposure");
344 declareImageFitsReader(wrappers);
345 declareMaskFitsReader(wrappers);
346 declareMaskedImageFitsReader(wrappers);
347 declareExposureFitsReader(wrappers);
348}

◆ wrapTransmissionCurve()

void lsst::afw::image::wrapTransmissionCurve ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 46 of file _transmissionCurve.cc.

46 {
47 wrappers.addInheritanceDependency("lsst.afw.typehandling");
48 wrappers.addSignatureDependency("lsst.afw.geom");
49 wrappers.wrapType(PyTransmissionCurve(wrappers.module, "TransmissionCurve"), [](auto &mod, auto &cls) {
50 table::io::python::addPersistableMethods(cls);
51
52 cls.def_static("makeIdentity", &TransmissionCurve::makeIdentity);
53 cls.def_static("makeSpatiallyConstant", &TransmissionCurve::makeSpatiallyConstant, "throughput"_a,
54 "wavelengths"_a, "throughputAtMin"_a = 0.0, "throughputAtMax"_a = 0.0);
55 cls.def_static("makeRadial", &TransmissionCurve::makeRadial, "throughput"_a, "wavelengths"_a,
56 "radii"_a, "throughputAtMin"_a = 0.0, "throughputAtMax"_a = 0.0);
57 cls.def("__mul__", &TransmissionCurve::multipliedBy, py::is_operator());
58 cls.def("multipliedBy", &TransmissionCurve::multipliedBy);
59 cls.def("transformedBy", &TransmissionCurve::transformedBy, "transform"_a);
60 cls.def("getWavelengthBounds", &TransmissionCurve::getWavelengthBounds);
61 cls.def("getThroughputAtBounds", &TransmissionCurve::getThroughputAtBounds);
62 cls.def("sampleAt",
63 (void (TransmissionCurve::*)(lsst::geom::Point2D const &,
64 ndarray::Array<double const, 1, 1> const &,
65 ndarray::Array<double, 1, 1> const &) const) &
66 TransmissionCurve::sampleAt,
67 "position"_a, "wavelengths"_a, "out"_a);
68 cls.def("sampleAt",
69 (ndarray::Array<double, 1, 1>(TransmissionCurve::*)(
70 lsst::geom::Point2D const &, ndarray::Array<double const, 1, 1> const &) const) &
71 TransmissionCurve::sampleAt,
72 "position"_a, "wavelengths"_a);
73 });
74}
py::class_< TransmissionCurve, std::shared_ptr< TransmissionCurve >, typehandling::Storable > PyTransmissionCurve

◆ wrapVisitInfo()

void lsst::afw::image::wrapVisitInfo ( lsst::utils::python::WrapperCollection & wrappers)

Definition at line 158 of file _visitInfo.cc.

158 {
159 wrappers.addInheritanceDependency("lsst.daf.base");
160 wrappers.addInheritanceDependency("lsst.geom");
161 wrappers.addInheritanceDependency("lsst.afw.coord");
162 wrappers.addInheritanceDependency("lsst.afw.typehandling");
163 declareRotType(wrappers);
164 declareVisitInfo(wrappers);
165 wrappers.wrap([](auto &mod) {
166 /* Free Functions */
167 mod.def("setVisitInfoMetadata", &detail::setVisitInfoMetadata, "metadata"_a, "visitInfo"_a);
168 mod.def("stripVisitInfoKeywords", &detail::stripVisitInfoKeywords, "metadata"_a);
169 });
170}
void declareVisitInfo(lsst::utils::python::WrapperCollection &wrappers)
Definition _visitInfo.cc:57
void declareRotType(lsst::utils::python::WrapperCollection &wrappers)

Variable Documentation

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