LSSTApplications  17.0+103,17.0+11,17.0+61,18.0.0+13,18.0.0+25,18.0.0+5,18.0.0+52,18.0.0-4-g68ffd23,18.1.0-1-g0001055+8,18.1.0-1-g03d53ef+1,18.1.0-1-g1349e88+28,18.1.0-1-g2505f39+22,18.1.0-1-g380d4d4+27,18.1.0-1-g5315e5e+1,18.1.0-1-g5e4b7ea+10,18.1.0-1-g7e8fceb+1,18.1.0-1-g85f8cd4+23,18.1.0-1-g9a6769a+13,18.1.0-1-ga1a4c1a+22,18.1.0-1-gd55f500+17,18.1.0-12-g42eabe8e+10,18.1.0-14-gd04256d+15,18.1.0-16-g430f6a53+1,18.1.0-17-gd2166b6e4,18.1.0-18-gb5d19ff+1,18.1.0-2-gfbf3545+7,18.1.0-2-gfefb8b5+16,18.1.0-3-g52aa583+13,18.1.0-3-g62b5e86+14,18.1.0-3-g8f4a2b1+17,18.1.0-3-g9bc06b8+7,18.1.0-3-gb69f684+9,18.1.0-4-g1ee41a7+1,18.1.0-5-g6dbcb01+13,18.1.0-5-gc286bb7+3,18.1.0-6-g48bdcd3+2,18.1.0-6-gd05e160+9,18.1.0-7-gc4d902b+2,18.1.0-7-gebc0338+8,18.1.0-9-gae7190a+10,w.2019.37
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
 
 maskedImage
 
 photoCalibContinued
 
 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  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...
 
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...
 
std::shared_ptr< daf::base::PropertyListreadMetadata (std::string const &fileName, int hdu=fits::DEFAULT_HDU, bool strip=false)
 Return the metadata (header entries) from a FITS file. 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 (readMetadata, 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.

◆ 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 };
Rotation angle is unknown.
Position angle of focal plane +Y, measured from N through E.
Position angle of focal plane +Y, measured from +Alt through +Az.
The position sent to the instrument rotator; the details depend on the rotator.

◆ xOrY

Enumerator

Definition at line 36 of file ImageUtils.h.

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 }
Angle abs(Angle const &a)
Definition: Angle.h:106
T log(T... args)

◆ abMagErrFromFluxErr() [2/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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
template ndarray::Array< double, 1 > abMagErrFromFluxErr(ndarray::Array< double const, 1 > const &fluxErr, ndarray::Array< double const, 1 > const &flux)
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

◆ 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 ndarray::Array< double , 1> lsst::afw::image::abMagErrFromFluxErr ( ndarray::Array< double const, 1 > const &  fluxErr,
ndarray::Array< double const, 1 > const &  flux 
)

◆ 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); }
T log10(T... args)

◆ abMagFromFlux() [2/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 }
template ndarray::Array< double, 1 > 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 ndarray::Array< double , 1> lsst::afw::image::abMagFromFlux ( ndarray::Array< double const, 1 > const &  flux)

◆ 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 71 of file PhotoCalib.h.

71  {
72  if (value < 0) {
74  (boost::format("%s must be positive: %.3g") % name % value).str());
75  }
76 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
Reports invalid arguments.
Definition: Runtime.h:66

◆ 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 77 of file Utils.h.

79  {
80  typedef typename ImageT::SinglePixel SinglePixelT;
83  : bad);
84 }

◆ bboxFromMetadata()

lsst::geom::Box2I lsst::afw::image::bboxFromMetadata ( daf::base::PropertySet metadata)

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

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

Definition at line 694 of file Image.cc.

694  {
696  if (metadata.exists("ZNAXIS1") && metadata.exists("ZNAXIS2")) {
697  dims = lsst::geom::Extent2I(metadata.getAsInt("ZNAXIS1"), metadata.getAsInt("ZNAXIS2"));
698  } else {
699  dims = lsst::geom::Extent2I(metadata.getAsInt("NAXIS1"), metadata.getAsInt("NAXIS2"));
700  }
702  return lsst::geom::Box2I(xy0, dims);
703 }
Extent< int, 2 > Extent2I
Definition: Extent.h:397
lsst::geom::Point2I getImageXY0FromMetadata(daf::base::PropertySet &metadata, std::string const &wcsName, bool strip=false)
Definition: wcsUtils.cc:98
std::string const wcsNameForXY0
Definition: ImageBase.h:70

◆ 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 }
ndarray::Array< T, 1 > fluxFromABMag(ndarray::Array< T const, 1 > const &mag)
Compute flux in Janskys from AB magnitude.
Definition: Calib.cc:68
Angle abs(Angle const &a)
Definition: Angle.h:106
T log(T... args)

◆ fluxErrFromABMagErr() [2/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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
template ndarray::Array< double, 1 > fluxErrFromABMagErr(ndarray::Array< double const, 1 > const &magErr, ndarray::Array< double const, 1 > const &mag)
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

◆ 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 ndarray::Array< double , 1> lsst::afw::image::fluxErrFromABMagErr ( ndarray::Array< double const, 1 > const &  magErr,
ndarray::Array< double const, 1 > const &  mag 
)

◆ 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; }
T pow(T... args)

◆ fluxFromABMag() [2/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 }
template ndarray::Array< double, 1 > 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 ndarray::Array< double , 1> lsst::afw::image::fluxFromABMag ( ndarray::Array< double const, 1 > const &  mag)

◆ for_each_pixel() [1/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 }
int y
Definition: SpanSet.cc:49

◆ for_each_pixel() [2/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 }
int y
Definition: SpanSet.cc:49

◆ for_each_pixel() [3/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 }
int y
Definition: SpanSet.cc:49
double x

◆ for_each_pixel() [4/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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
Reports attempts to exceed implementation-defined length limits for some classes. ...
Definition: Runtime.h:76
int y
Definition: SpanSet.cc:49
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

◆ for_each_pixel() [5/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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
Reports attempts to exceed implementation-defined length limits for some classes. ...
Definition: Runtime.h:76
int y
Definition: SpanSet.cc:49
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

◆ for_each_pixel() [6/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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
Reports attempts to exceed implementation-defined length limits for some classes. ...
Definition: Runtime.h:76
int y
Definition: SpanSet.cc:49
double x
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h: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 706 of file Image.cc.

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

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

672  {
673  return imagesOverlap(*image1.getImage(), *image2.getImage()) ||
674  imagesOverlap(*image1.getVariance(), *image2.getVariance()) ||
675  imagesOverlap(*image1.getMask(), *image2.getMask());
676 }
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:706

◆ 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 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 }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:167
float Pixel
Typedefs to be used for pixel values.
Definition: common.h:37
Reports attempts to exceed implementation-defined length limits for some classes. ...
Definition: Runtime.h:76
int y
Definition: SpanSet.cc:49
ImageT val
Definition: CR.cc:146
T isfinite(T... args)
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

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

457  {
459  new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
460 }
table::Key< table::Array< std::uint8_t > > wcs
Definition: SkyWcs.cc:71

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

1281  {
1282  return new MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>(image, mask, variance);
1283 }
afw::table::Key< afw::table::Array< VariancePixelT > > variance
afw::table::Key< afw::table::Array< ImagePixelT > > image
afw::table::Key< afw::table::Array< MaskPixelT > > mask

◆ 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 642 of file PhotoCalib.cc.

642  {
643  double calibration = utils::referenceFlux / instFluxMag0;
644  double calibrationErr = utils::referenceFlux * instFluxMag0Err / std::pow(instFluxMag0, 2);
645  return std::make_shared<PhotoCalib>(calibration, calibrationErr);
646 }
T pow(T... args)
const double referenceFlux
The Oke & Gunn (1983) AB magnitude reference flux, in nJy (often approximated as 3631.0).
Definition: Magnitude.h:46
table::Key< double > calibrationErr
Definition: PhotoCalib.cc:399

◆ 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 624 of file PhotoCalib.cc.

624  {
625  auto key = "FLUXMAG0";
626  if (metadata.exists(key)) {
627  double instFluxMag0 = metadata.getAsDouble(key);
628  if (strip) metadata.remove(key);
629 
630  double instFluxMag0Err = 0.0;
631  key = "FLUXMAG0ERR";
632  if (metadata.exists(key)) {
633  instFluxMag0Err = metadata.getAsDouble(key);
634  if (strip) metadata.remove(key);
635  }
636  return makePhotoCalibFromCalibZeroPoint(instFluxMag0, instFluxMag0Err);
637  } else {
638  return nullptr;
639  }
640 }
std::shared_ptr< PhotoCalib > makePhotoCalibFromCalibZeroPoint(double instFluxMag0, double instFluxMag0Err)
Construct a PhotoCalib from the deprecated Calib-style instFluxMag0/instFluxMag0Err values...
Definition: PhotoCalib.cc:642
Key< U > key
Definition: Schema.cc:281
bool strip
Definition: fits.cc:883

◆ 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 }
constexpr Angle operator*(Angle a, Angle d) noexcept
Product of two angles.
Definition: Angle.h:322

◆ operator*=() [1/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*=() [2/2]

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

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

Definition at line 683 of file Image.cc.

683  {
684  for_each_pixel(lhs, rhs, timesEq<LhsPixelT, RhsPixelT>());
685  return lhs;
686 }
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()

◆ 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 }
constexpr Angle operator+(Angle a, Angle d) noexcept
Sum of two angles.
Definition: Angle.h:308

◆ operator+=() [1/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+=() [2/2]

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

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

Definition at line 671 of file Image.cc.

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

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

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

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

Definition at line 677 of file Image.cc.

677  {
678  for_each_pixel(lhs, rhs, minusEq<LhsPixelT, RhsPixelT>());
679  return lhs;
680 }
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()

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

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

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

Definition at line 689 of file Image.cc.

689  {
690  for_each_pixel(lhs, rhs, divideEq<LhsPixelT, RhsPixelT>());
691  return lhs;
692 }
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()

◆ operator<<() [1/3]

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

Definition at line 48 of file PhotoCalib.cc.

48  {
50  s << std::setprecision(std::numeric_limits<long double>::digits10 + 1);
51  s << "value=" << measurement.value << ", error=" << measurement.error;
52  return os << s.str();
53 }
T str(T... args)
solver_t * s

◆ operator<<() [2/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 }
std::ostream * os
Definition: Schema.cc:746

◆ operator<<() [3/3]

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

Definition at line 285 of file PhotoCalib.cc.

285  {
286  return os << photoCalib.toString();
287 }

◆ positionToIndex() [1/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 }
T floor(T... args)
const double PixelZeroPos
position of center of pixel 0
Definition: ImageUtils.h:44

◆ positionToIndex() [2/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)
const double PixelZeroPos
position of center of pixel 0
Definition: ImageUtils.h:44

◆ positionToIndex() [3/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 }
std::pair< int, double > positionToIndex(double const pos, bool)
Convert image position to index (nearest integer and fractional parts)
Definition: ImageUtils.h:98

◆ PYBIND11_MODULE() [1/4]

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

Definition at line 34 of file readMetadata.cc.

34  { // wraps code in Utils.h, but there's an unrelated utils.py
35  /* Module level */
36  mod.def("readMetadata", readMetadata, "fileName"_a, "hdu"_a = fits::DEFAULT_HDU, "strip"_a = false);
37 }
const int DEFAULT_HDU
Specify that the default HDU should be read.
Definition: fitsDefaults.h:18

◆ PYBIND11_MODULE() [2/4]

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 }
std::int64_t RecordId
Type used for unique IDs for records.
Definition: misc.h:22
void addOutputOp(PyClass &cls, std::string const &method)
Add __str__ or __repr__ method implemented by operator<<.
Definition: python.h:87
RotType
Type of rotation.
Definition: VisitInfo.h:45
def init()
Definition: tests.py:64
ItemVariant const * other
Definition: Schema.cc:56
A class representing an angle.
Definition: Angle.h:127
void setVisitInfoMetadata(daf::base::PropertyList &metadata, VisitInfo const &visitInfo)
Set FITS metadata from a VisitInfo.
Definition: VisitInfo.cc:281
Point in an unspecified spherical coordinate system.
Definition: SpherePoint.h:57
int stripVisitInfoKeywords(daf::base::PropertySet &metadata)
Remove VisitInfo-related keywords from the metadata.
Definition: VisitInfo.cc:265

◆ PYBIND11_MODULE() [3/4]

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

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

Definition at line 229 of file maskedImage.cc.

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

◆ readMetadata()

std::shared_ptr<daf::base::PropertyList> lsst::afw::image::readMetadata ( std::string const &  fileName,
int  hdu = fits::DEFAULT_HDU,
bool  strip = false 
)
inline

Return the metadata (header entries) from a FITS file.

Deprecated:
Use lsst::afw::fits::readMetadata instead.
Parameters
[in]fileNameFile to read.
[in]hduHDU to read, 0-indexed. The special value of afw::fits::DEFAULT_HDU will read the first non-empty HDU.
[in]stripIf true, ignore special header keys usually managed by cfitsio (e.g. NAXIS).

Definition at line 63 of file Utils.h.

65  {
66  return afw::fits::readMetadata(fileName, hdu, strip);
67 }
std::shared_ptr< daf::base::PropertyList > readMetadata(std::string const &fileName, int hdu=fits::DEFAULT_HDU, bool strip=false)
Return the metadata (header entries) from a FITS file.
Definition: Utils.h:63
bool strip
Definition: fits.cc:883

◆ swap() [1/4]

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

Definition at line 456 of file Image.cc.

456  {
457  a.swap(b);
458 }
table::Key< int > b
table::Key< int > a

◆ swap() [2/4]

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

Definition at line 255 of file Image.cc.

255  {
256  a.swap(b);
257 }
table::Key< int > b
table::Key< int > a

◆ swap() [3/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 }
table::Key< int > b
table::Key< int > a

◆ 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 }
table::Key< int > b
table::Key< int > a

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.