LSSTApplications  19.0.0-14-gb0260a2+72efe9b372,20.0.0+7927753e06,20.0.0+8829bf0056,20.0.0+995114c5d2,20.0.0+b6f4b2abd1,20.0.0+bddc4f4cbe,20.0.0-1-g253301a+8829bf0056,20.0.0-1-g2b7511a+0d71a2d77f,20.0.0-1-g5b95a8c+7461dd0434,20.0.0-12-g321c96ea+23efe4bbff,20.0.0-16-gfab17e72e+fdf35455f6,20.0.0-2-g0070d88+ba3ffc8f0b,20.0.0-2-g4dae9ad+ee58a624b3,20.0.0-2-g61b8584+5d3db074ba,20.0.0-2-gb780d76+d529cf1a41,20.0.0-2-ged6426c+226a441f5f,20.0.0-2-gf072044+8829bf0056,20.0.0-2-gf1f7952+ee58a624b3,20.0.0-20-geae50cf+e37fec0aee,20.0.0-25-g3dcad98+544a109665,20.0.0-25-g5eafb0f+ee58a624b3,20.0.0-27-g64178ef+f1f297b00a,20.0.0-3-g4cc78c6+e0676b0dc8,20.0.0-3-g8f21e14+4fd2c12c9a,20.0.0-3-gbd60e8c+187b78b4b8,20.0.0-3-gbecbe05+48431fa087,20.0.0-38-ge4adf513+a12e1f8e37,20.0.0-4-g97dc21a+544a109665,20.0.0-4-gb4befbc+087873070b,20.0.0-4-gf910f65+5d3db074ba,20.0.0-5-gdfe0fee+199202a608,20.0.0-5-gfbfe500+d529cf1a41,20.0.0-6-g64f541c+d529cf1a41,20.0.0-6-g9a5b7a1+a1cd37312e,20.0.0-68-ga3f3dda+5fca18c6a4,20.0.0-9-g4aef684+e18322736b,w.2020.45
LSSTDataManagementBasePackage
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
lsst::afw::image Namespace Reference

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

Namespaces

 apCorrMap
 
 basicUtils
 
 detail
 
 details
 
 disableArithmetic
 
 exposure
 
 image
 
 impl
 
 maskedImage
 
 pixel
 
 python
 
 SdssFilters
 
 slicing
 
 testUtils
 
 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  Filter
 Holds an integer identifier for an LSST filter. More...
 
class  FilterLabel
 A group of labels for a filter in an exposure or coadd. More...
 
class  FilterProperty
 Describe the properties of a Filter (e.g. 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

typedef std::int32_t MaskPixel
 default type for Masks and MaskedImage Masks More...
 
typedef float VariancePixel
 default type for MaskedImage variance images More...
 

Enumerations

enum  ImageOrigin { PARENT, LOCAL }
 
enum  xOrY { X, Y }
 
enum  RotType { RotType::UNKNOWN, RotType::SKY, RotType::HORIZON, RotType::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...
 
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::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. More...
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromMetadata (daf::base::PropertySet &metadata, bool strip=false)
 Construct a PhotoCalib from FITS FLUXMAG0/FLUXMAG0ERR keywords. More...
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromCalibZeroPoint (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::ostreamoperator<< (std::ostream &os, VisitInfo const &visitInfo)
 
 PYBIND11_MODULE (imagePca, mod)
 
 PYBIND11_MODULE (maskedImage, mod)
 
 PYBIND11_MODULE (visitInfo, 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)
 
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)
 

Variables

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

default type for Masks and MaskedImage Masks

Definition at line 34 of file LsstImageTypes.h.

◆ 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

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,
47  SKY,
49  HORIZON,
52  MOUNT
55 };

◆ xOrY

Enumerator

Definition at line 36 of file ImageUtils.h.

36 { X, Y };

Function Documentation

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

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

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

53  {
54  if (flux.getNumElements() != fluxErr.getNumElements()) {
55  throw LSST_EXCEPT(pex::exceptions::LengthError, (boost::format("Length mismatch: %d vs %d") %
56  flux.getNumElements() % fluxErr.getNumElements())
57  .str());
58  }
59  ndarray::Array<T, 1> out = ndarray::allocate(flux.getShape());
60  for (std::size_t ii = 0; ii < flux.getNumElements(); ++ii) {
61  out[ii] = abMagErrFromFluxErr(fluxErr[ii], flux[ii]);
62  }
63  return out;
64 }

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

49 { 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.

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

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

◆ 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
badThe bad value if NaN isn't supported

Definition at line 60 of file Utils.h.

62  {
63  typedef typename ImageT::SinglePixel SinglePixelT;
66  : bad);
67 }

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

688  {
690  if (metadata.exists("ZNAXIS1") && metadata.exists("ZNAXIS2")) {
691  dims = lsst::geom::Extent2I(metadata.getAsInt("ZNAXIS1"), metadata.getAsInt("ZNAXIS2"));
692  } else {
693  dims = lsst::geom::Extent2I(metadata.getAsInt("NAXIS1"), metadata.getAsInt("NAXIS2"));
694  }
696  return lsst::geom::Box2I(xy0, dims);
697 }

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

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

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

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

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

57 { 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.

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

◆ 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 145 of file ImageAlgorithm.h.

148  {
149  if (lhs.getDimensions() != rhs.getDimensions()) {
151  (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
152  lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
153  .str());
154  }
155 
156  for (int y = 0; y != lhs.getHeight(); ++y) {
157  typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
158 
159  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
160  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
161  *lhsPtr = func(*rhsPtr);
162  }
163  }
164 }

◆ 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 170 of file ImageAlgorithm.h.

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

◆ 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 196 of file ImageAlgorithm.h.

199  {
200  if (lhs.getDimensions() != rhs.getDimensions()) {
202  (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
203  lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
204  .str());
205  }
206 
207  for (int y = 0; y != lhs.getHeight(); ++y) {
208  typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
209  int x = lhs.getX0();
210  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
211  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
212  *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
213  }
214  }
215 }

◆ 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
Examples
forEachPixel.cc.

Definition at line 97 of file ImageAlgorithm.h.

99  {
100  for (int y = 0; y != lhs.getHeight(); ++y) {
101  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
102  lhsPtr != lhsEnd; ++lhsPtr) {
103  *lhsPtr = func();
104  }
105  }
106 }

◆ 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 112 of file ImageAlgorithm.h.

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

◆ 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 129 of file ImageAlgorithm.h.

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

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

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

700  {
701  auto arr1 = image1.getArray();
702  // get the address of the first and one-past-the-last element of arr1 using ndarray iterators;
703  // this works because the iterators for contiguous 1-d ndarray Arrays are just pointers
704  auto beg1Addr = arr1.front().begin();
705  auto end1Addr = arr1.back().end();
706 
707  auto arr2 = image2.getArray();
708  auto beg2Addr = arr2.front().begin();
709  auto end2Addr = arr2.back().end();
710 
711  auto ptrLess = std::less<void const* const>();
712  return ptrLess(beg1Addr, end2Addr) && ptrLess(beg2Addr, end1Addr);
713 }

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

665  {
666  return imagesOverlap(*image1.getImage(), *image2.getImage()) ||
667  imagesOverlap(*image1.getVariance(), *image2.getVariance()) ||
668  imagesOverlap(*image1.getMask(), *image2.getMask());
669 }

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

◆ 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 415 of file ImagePca.cc.

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

◆ 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 442 of file Exposure.h.

446  {
448  new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
449 }

◆ 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 1268 of file MaskedImage.h.

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

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

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

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

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

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

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

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

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

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

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

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

671  {
672  for_each_pixel(lhs, rhs, minusEq<LhsPixelT, RhsPixelT>());
673  return lhs;
674 }

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

683  {
684  for_each_pixel(lhs, rhs, divideEq<LhsPixelT, RhsPixelT>());
685  return lhs;
686 }

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

◆ 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 474 of file VisitInfo.cc.

474  {
475  os << visitInfo.toString();
476  return os;
477 }

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

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

◆ 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 ( imagePca  ,
mod   
)

Definition at line 63 of file imagePca.cc.

63  {
64  declareImagePca<Image<int>>(mod, "I");
65  declareImagePca<Image<float>>(mod, "F");
66  declareImagePca<Image<double>>(mod, "D");
67  declareImagePca<Image<std::uint16_t>>(mod, "U");
68  declareImagePca<Image<std::uint64_t>>(mod, "L");
69  declareImagePca<MaskedImage<int>>(mod, "MI");
70  declareImagePca<MaskedImage<float>>(mod, "MF");
71  declareImagePca<MaskedImage<double>>(mod, "MD");
72  declareImagePca<MaskedImage<std::uint16_t>>(mod, "MU");
73  declareImagePca<MaskedImage<std::uint64_t>>(mod, "ML");
74 
75  declareInnerProduct<Image<int>, Image<int>>(mod);
76  declareInnerProduct<Image<float>, Image<float>>(mod);
77  declareInnerProduct<Image<double>, Image<double>>(mod);
78  declareInnerProduct<Image<std::uint16_t>, Image<std::uint16_t>>(mod);
79  declareInnerProduct<Image<std::uint64_t>, Image<std::uint64_t>>(mod);
80 
81  declareInnerProduct<Image<float>, Image<double>>(mod);
82  declareInnerProduct<Image<double>, Image<float>>(mod);
83 }

◆ PYBIND11_MODULE() [2/3]

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

Definition at line 228 of file maskedImage.cc.

228  {
229  py::module::import("lsst.afw.image.image");
230 
231  auto clsMaskedImageF = declareMaskedImage<float>(mod, "F");
232  auto clsMaskedImageD = declareMaskedImage<double>(mod, "D");
233  auto clsMaskedImageI = declareMaskedImage<int>(mod, "I");
234  auto clsMaskedImageU = declareMaskedImage<std::uint16_t>(mod, "U");
235  auto clsMaskedImageL = declareMaskedImage<std::uint64_t>(mod, "L");
236 
237  // Declare constructors for casting all exposure types to to float and double
238  // (the only two types of casts that Python supports)
239  declareCastConstructor<int, float>(clsMaskedImageF);
240  declareCastConstructor<int, double>(clsMaskedImageD);
241  declareCastConstructor<float, double>(clsMaskedImageD);
242  declareCastConstructor<double, float>(clsMaskedImageF);
243  declareCastConstructor<std::uint16_t, float>(clsMaskedImageF);
244  declareCastConstructor<std::uint16_t, double>(clsMaskedImageD);
245  declareCastConstructor<std::uint64_t, float>(clsMaskedImageF);
246  declareCastConstructor<std::uint64_t, double>(clsMaskedImageD);
247 
248  /* Module level */
249  declareMakeMaskedImage<int>(mod);
250  declareMakeMaskedImage<float>(mod);
251  declareMakeMaskedImage<double>(mod);
252  declareMakeMaskedImage<std::uint16_t>(mod);
253  declareMakeMaskedImage<std::uint64_t>(mod);
254 
255  declareImagesOverlap<int, int>(mod);
256  declareImagesOverlap<int, float>(mod);
257  declareImagesOverlap<int, double>(mod);
258  declareImagesOverlap<int, std::uint16_t>(mod);
259  declareImagesOverlap<int, std::uint64_t>(mod);
260 
261  declareImagesOverlap<float, int>(mod);
262  declareImagesOverlap<float, float>(mod);
263  declareImagesOverlap<float, double>(mod);
264  declareImagesOverlap<float, std::uint16_t>(mod);
265  declareImagesOverlap<float, std::uint64_t>(mod);
266 
267  declareImagesOverlap<double, int>(mod);
268  declareImagesOverlap<double, float>(mod);
269  declareImagesOverlap<double, double>(mod);
270  declareImagesOverlap<double, std::uint16_t>(mod);
271  declareImagesOverlap<double, std::uint64_t>(mod);
272 
273  declareImagesOverlap<std::uint16_t, int>(mod);
274  declareImagesOverlap<std::uint16_t, float>(mod);
275  declareImagesOverlap<std::uint16_t, double>(mod);
276  declareImagesOverlap<std::uint16_t, std::uint16_t>(mod);
277  declareImagesOverlap<std::uint16_t, std::uint64_t>(mod);
278 
279  declareImagesOverlap<std::uint64_t, int>(mod);
280  declareImagesOverlap<std::uint64_t, float>(mod);
281  declareImagesOverlap<std::uint64_t, double>(mod);
282  declareImagesOverlap<std::uint64_t, std::uint16_t>(mod);
283  declareImagesOverlap<std::uint64_t, std::uint64_t>(mod);
284 }

◆ PYBIND11_MODULE() [3/3]

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

Definition at line 55 of file visitInfo.cc.

55  {
56  py::module::import("lsst.daf.base");
57  py::module::import("lsst.geom");
58  py::module::import("lsst.afw.coord.observatory");
59  py::module::import("lsst.afw.coord.weather");
60  py::module::import("lsst.afw.typehandling");
61 
62  /* Module level */
63  py::class_<VisitInfo, std::shared_ptr<VisitInfo>, typehandling::Storable> cls(mod, "VisitInfo");
64 
65  /* Member types and enums */
66  py::enum_<RotType>(mod, "RotType")
67  .value("UNKNOWN", RotType::UNKNOWN)
68  .value("SKY", RotType::SKY)
69  .value("HORIZON", RotType::HORIZON)
70  .value("MOUNT", RotType::MOUNT)
71  .export_values();
72 
73  /* Constructors */
74  cls.def(py::init<table::RecordId, double, double, daf::base::DateTime const &, double,
75  lsst::geom::Angle const &, lsst::geom::SpherePoint const &, lsst::geom::SpherePoint const &, double,
76  lsst::geom::Angle const &, RotType const &, coord::Observatory const &,
77  coord::Weather const &>(),
78  "exposureId"_a = 0, "exposureTime"_a = nan, "darkTime"_a = nan, "date"_a = daf::base::DateTime(),
79  "ut1"_a = nan, "era"_a = nanAngle, "boresightRaDec"_a = lsst::geom::SpherePoint(nanAngle, nanAngle),
80  "boresightAzAlt"_a = lsst::geom::SpherePoint(nanAngle, nanAngle), "boresightAirmass"_a = nan,
81  "boresightRotAngle"_a = nanAngle, "rotType"_a = RotType::UNKNOWN,
82  "observatory"_a = coord::Observatory(nanAngle, nanAngle, nan),
83  "weather"_a = coord::Weather(nan, nan, nan));
84  cls.def(py::init<daf::base::PropertySet const &>(), "metadata"_a);
85  cls.def(py::init<VisitInfo const &>(), "visitInfo"_a);
86 
87  table::io::python::addPersistableMethods<VisitInfo>(cls);
88 
89  /* Operators */
90  cls.def("__eq__", [](VisitInfo const &self, VisitInfo const &other) { return self == other; },
91  py::is_operator());
92  cls.def("__ne__", [](VisitInfo const &self, VisitInfo const &other) { return self != other; },
93  py::is_operator());
94 
95  /* Members */
96  cls.def("getExposureId", &VisitInfo::getExposureId);
97  cls.def("getExposureTime", &VisitInfo::getExposureTime);
98  cls.def("getDarkTime", &VisitInfo::getDarkTime);
99  cls.def("getDate", &VisitInfo::getDate);
100  cls.def("getUt1", &VisitInfo::getUt1);
101  cls.def("getEra", &VisitInfo::getEra);
102  cls.def("getBoresightRaDec", &VisitInfo::getBoresightRaDec);
103  cls.def("getBoresightAzAlt", &VisitInfo::getBoresightAzAlt);
104  cls.def("getBoresightAirmass", &VisitInfo::getBoresightAirmass);
105  cls.def("getBoresightParAngle", &VisitInfo::getBoresightParAngle);
106  cls.def("getBoresightRotAngle", &VisitInfo::getBoresightRotAngle);
107  cls.def("getRotType", &VisitInfo::getRotType);
108  cls.def("getObservatory", &VisitInfo::getObservatory);
109  cls.def("getWeather", &VisitInfo::getWeather);
110  cls.def("isPersistable", &VisitInfo::isPersistable);
111  cls.def("getLocalEra", &VisitInfo::getLocalEra);
112  cls.def("getBoresightHourAngle", &VisitInfo::getBoresightHourAngle);
113 
114  utils::python::addOutputOp(cls, "__str__");
115 
116  /* Free Functions */
117  mod.def("setVisitInfoMetadata", &detail::setVisitInfoMetadata, "metadata"_a, "visitInfo"_a);
118  mod.def("stripVisitInfoKeywords", &detail::stripVisitInfoKeywords, "metadata"_a);
119 }

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

90  {
91  a.swap(b);
92 }

◆ swap() [2/4]

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

Definition at line 450 of file Image.cc.

450  {
451  a.swap(b);
452 }

◆ swap() [3/4]

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

Definition at line 249 of file Image.cc.

249  {
250  a.swap(b);
251 }

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

141  {
142  a.swap(b);
143 }

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.

y
int y
Definition: SpanSet.cc:49
lsst::afw::image::RotType
RotType
Type of rotation.
Definition: VisitInfo.h:45
lsst::utils::python::addOutputOp
void addOutputOp(PyClass &cls, std::string const &method)
Add __str__ or __repr__ method implemented by operator<<.
Definition: python.h:87
lsst::afw::image
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
Definition: imageAlgorithm.dox:1
std::setprecision
T setprecision(T... args)
std::floor
T floor(T... args)
lsst::afw::image::LOCAL
@ LOCAL
Definition: ImageBase.h:94
lsst::utils::referenceFlux
const double referenceFlux
The Oke & Gunn (1983) AB magnitude reference flux, in nJy (often approximated as 3631....
Definition: Magnitude.h:46
std::shared_ptr
STL class.
lsst::afw::table::RecordId
std::int64_t RecordId
Type used for unique IDs for records.
Definition: misc.h:22
lsst::geom::Angle::operator+
constexpr Angle operator+(Angle a, Angle d) noexcept
Sum of two angles.
Definition: Angle.h:308
std::pair
lsst::meas::modelfit::Pixel
float Pixel
Typedefs to be used for pixel values.
Definition: common.h:37
wcs
table::Key< table::Array< std::uint8_t > > wcs
Definition: SkyWcs.cc:71
lsst::afw::image::abMagErrFromFluxErr
template ndarray::Array< double, 1 > abMagErrFromFluxErr(ndarray::Array< double const, 1 > const &fluxErr, ndarray::Array< double const, 1 > const &flux)
lsst::afw::image::PixelZeroPos
const double PixelZeroPos
position of center of pixel 0
Definition: ImageUtils.h:44
lsst::afw::image::detail::setVisitInfoMetadata
void setVisitInfoMetadata(daf::base::PropertyList &metadata, VisitInfo const &visitInfo)
Set FITS metadata from a VisitInfo.
Definition: VisitInfo.cc:281
lsst::sphgeom::abs
Angle abs(Angle const &a)
Definition: Angle.h:106
calibrationErr
table::Key< double > calibrationErr
Definition: PhotoCalib.cc:371
std::stringstream
STL class.
lsst::afw::image::RotType::UNKNOWN
@ UNKNOWN
Rotation angle is unknown.
strip
bool strip
Definition: fits.cc:911
lsst.pex.config.history.format
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
lsst::afw::image::makePhotoCalibFromCalibZeroPoint
std::shared_ptr< PhotoCalib > makePhotoCalibFromCalibZeroPoint(double instFluxMag0, double instFluxMag0Err)
Construct a PhotoCalib from the deprecated Calib-style instFluxMag0/instFluxMag0Err values.
Definition: PhotoCalib.cc:614
val
ImageT val
Definition: CR.cc:146
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::afw::image::X
@ X
Definition: ImageUtils.h:36
mask
afw::table::Key< afw::table::Array< MaskPixelT > > mask
Definition: HeavyFootprint.cc:217
std::less
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
lsst::geom::Angle::operator*
constexpr Angle operator*(Angle a, Angle d) noexcept
Product of two angles.
Definition: Angle.h:322
std::isfinite
T isfinite(T... args)
std::log
T log(T... args)
x
double x
Definition: ChebyshevBoundedField.cc:277
lsst.pex::exceptions::LengthError
Reports attempts to exceed implementation-defined length limits for some classes.
Definition: Runtime.h:76
lsst::afw::image::RotType::SKY
@ SKY
Position angle of focal plane +Y, measured from N through E.
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::image::RotType::HORIZON
@ HORIZON
Position angle of focal plane +Y, measured from +Alt through +Az.
lsst::afw::image::Y
@ Y
Definition: ImageUtils.h:36
std::regex
lsst::afw::image::positionToIndex
std::pair< int, double > positionToIndex(double const pos, bool)
Convert image position to index (nearest integer and fractional parts)
Definition: ImageUtils.h:98
b
table::Key< int > b
Definition: TransmissionCurve.cc:467
lsst::afw::image::detail::wcsNameForXY0
std::string const wcsNameForXY0
Definition: ImageBase.h:70
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
lsst::afw::image::for_each_pixel
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()
Definition: ImageAlgorithm.h:97
lsst.pipe.tasks.insertFakes.flux
flux
Definition: insertFakes.py:455
photoCalib
Key< int > photoCalib
Definition: Exposure.cc:67
os
std::ostream * os
Definition: Schema.cc:746
lsst::afw::image::fluxFromABMag
template ndarray::Array< double, 1 > fluxFromABMag(ndarray::Array< double const, 1 > const &mag)
variance
afw::table::Key< afw::table::Array< VariancePixelT > > variance
Definition: HeavyFootprint.cc:218
lsst::afw::image::RotType::MOUNT
@ MOUNT
The position sent to the instrument rotator; the details depend on the rotator.
lsst.pex::exceptions::InvalidParameterError
Reports invalid arguments.
Definition: Runtime.h:66
a
table::Key< int > a
Definition: TransmissionCurve.cc:466
lsst::geom::Extent2I
Extent< int, 2 > Extent2I
Definition: Extent.h:397
lsst::afw::image::abMagFromFlux
template ndarray::Array< double, 1 > abMagFromFlux(ndarray::Array< double const, 1 > const &flux)
key
Key< U > key
Definition: Schema.cc:281
lsst::geom::Point< int, 2 >
lsst::afw::image::fluxFromABMag
ndarray::Array< T, 1 > fluxFromABMag(ndarray::Array< T const, 1 > const &mag)
Compute flux in Janskys from AB magnitude.
Definition: Calib.cc:68
lsst::geom::Angle
A class representing an angle.
Definition: Angle.h:127
lsst::geom::Box2I
An integer coordinate rectangle.
Definition: Box.h:55
lsst::afw::geom::getImageXY0FromMetadata
lsst::geom::Point2I getImageXY0FromMetadata(daf::base::PropertySet &metadata, std::string const &wcsName, bool strip=false)
Definition: wcsUtils.cc:98
lsst::afw::image::PARENT
@ PARENT
Definition: ImageBase.h:94
std::log10
T log10(T... args)
std::stringstream::str
T str(T... args)
std::size_t
lsst::afw::image::imagesOverlap
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:700
lsst::geom::SpherePoint
Point in an unspecified spherical coordinate system.
Definition: SpherePoint.h:57
lsst::utils.tests.init
def init()
Definition: tests.py:59
lsst::afw::image::detail::stripVisitInfoKeywords
int stripVisitInfoKeywords(daf::base::PropertySet &metadata)
Remove VisitInfo-related keywords from the metadata.
Definition: VisitInfo.cc:265
lsst::geom::Extent< int, 2 >
std::numeric_limits
std::regex_replace
T regex_replace(T... args)
lsst::afw::image::fluxErrFromABMagErr
template ndarray::Array< double, 1 > fluxErrFromABMagErr(ndarray::Array< double const, 1 > const &magErr, ndarray::Array< double const, 1 > const &mag)
visitInfo
Key< int > visitInfo
Definition: Exposure.cc:70
std::pow
T pow(T... args)