lsst.meas.astrom g3b20d027df+5ae630fd38
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
lsst::afw::image Namespace Reference

Namespaces

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

Classes

class  ApCorrMap
 
class  CheckIndices
 
class  CoaddInputs
 
class  Color
 
struct  ConstReference
 
class  DecoratedImage
 
class  DefectBase
 
class  Exposure
 
class  ExposureFitsReader
 
class  ExposureInfo
 
class  FilterLabel
 
struct  GetImage
 
class  Image
 
class  ImageBase
 
class  ImageBaseFitsReader
 
class  ImageFitsReader
 
class  imageIterator
 
class  imageLocator
 
class  ImagePca
 
class  ImageSlice
 
class  Mask
 
class  MaskedImage
 
class  MaskedImageFitsReader
 
class  MaskFitsReader
 
struct  Measurement
 
class  PhotoCalib
 
struct  pixelOp0
 
struct  pixelOp1
 
struct  pixelOp1XY
 
struct  pixelOp2
 
struct  pixelOp2XY
 
struct  Reference
 
class  TransmissionCurve
 
class  VisitInfo
 

Typedefs

typedef std::int32_t MaskPixel
 
typedef float VariancePixel
 

Enumerations

enum  ImageOrigin
 
enum  xOrY
 
enum  RotType { UNKNOWN , SKY , HORIZON , MOUNT }
 

Functions

double abMagFromFlux (double flux)
 
double abMagErrFromFluxErr (double fluxErr, double flux)
 
double fluxFromABMag (double mag) noexcept
 
double fluxErrFromABMagErr (double magErr, double mag) noexcept
 
ndarray::Array< T, 1 > abMagFromFlux (ndarray::Array< T const, 1 > const &flux)
 
ndarray::Array< T, 1 > abMagErrFromFluxErr (ndarray::Array< T const, 1 > const &fluxErr, ndarray::Array< T const, 1 > const &flux)
 
ndarray::Array< T, 1 > fluxFromABMag (ndarray::Array< T const, 1 > const &mag)
 
ndarray::Array< T, 1 > fluxErrFromABMagErr (ndarray::Array< T const, 1 > const &magErr, ndarray::Array< T const, 1 > const &mag)
 
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 >())
 
 FilterProperty (FilterProperty const &)=default
 
 FilterProperty (FilterProperty &&) noexcept=default
 
FilterPropertyoperator= (FilterProperty const &)=default
 
FilterPropertyoperator= (FilterProperty &&) noexcept=default
 
 ~FilterProperty () noexcept=default
 
std::string const & getName () const noexcept
 
double getLambdaEff () const noexcept
 
double getLambdaMin () const noexcept
 
double getLambdaMax () const noexcept
 
bool operator== (FilterProperty const &rhs) const noexcept
 
bool operator!= (FilterProperty const &rhs) const noexcept
 
std::size_t hash_value () const noexcept
 
std::string getPersistenceName () const override
 
std::string getPythonModule () const override
 
void write (OutputArchiveHandle &handle) const override
 
std::string getDatabaseFilterLabel (std::string const &filterLabel)
 
Image< LhsPixelT > & operator+= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
 
Image< LhsPixelT > & operator-= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
 
Image< LhsPixelT > & operator*= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
 
Image< LhsPixelT > & operator/= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)
 
void swap (Image< PixelT > &a, Image< PixelT > &b)
 
void swap (DecoratedImage< PixelT > &a, DecoratedImage< PixelT > &b)
 
lsst::geom::Box2I bboxFromMetadata (daf::base::PropertySet &metadata)
 
bool imagesOverlap (ImageBase< T1 > const &image1, ImageBase< T2 > const &image2)
 
void for_each_pixel (Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
 
void for_each_pixel (Image< LhsT > &lhs, pixelOp1< LhsT > const &func)
 
void for_each_pixel (Image< LhsT > &lhs, pixelOp1XY< LhsT > const &func)
 
void for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp1< RhsT > const &func)
 
void for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2< LhsT, RhsT > const &func)
 
void for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2XY< LhsT, RhsT > const &func)
 
void swap (ImageBase< PixelT > &a, ImageBase< PixelT > &b)
 
double innerProduct (Image1T const &lhs, Image2T const &rhs, int const border=0)
 
std::shared_ptr< Image< PixelT > > operator+ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 
std::shared_ptr< Image< PixelT > > operator+ (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
 
void operator+= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 
std::shared_ptr< Image< PixelT > > operator- (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 
void operator-= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 
std::shared_ptr< Image< PixelT > > operator* (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 
std::shared_ptr< Image< PixelT > > operator* (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)
 
void operator*= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 
std::shared_ptr< Image< PixelT > > operator/ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)
 
void operator/= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
 
double indexToPosition (double ind)
 
int positionToIndex (double pos)
 
int positionToIndex (double &residual, double pos)
 
std::pair< int, double > positionToIndex (double const pos, bool)
 
void swap (Mask< PixelT > &a, Mask< PixelT > &b)
 
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 >())
 
bool imagesOverlap (MaskedImage< ImagePixelT1, MaskPixel, VariancePixel > const &image1, MaskedImage< ImagePixelT2, MaskPixel, VariancePixel > const &image2)
 
std::ostreamoperator<< (std::ostream &os, Measurement const &measurement)
 
void assertNonNegative (double value, std::string const &name)
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromMetadata (daf::base::PropertySet &metadata, bool strip=false)
 
std::shared_ptr< PhotoCalibmakePhotoCalibFromCalibZeroPoint (double instFluxMag0, double instFluxMag0Err)
 
std::ostreamoperator<< (std::ostream &os, VisitInfo const &visitInfo)
 
template ndarray::Array< float, 1 > abMagFromFlux (ndarray::Array< float const, 1 > const &flux)
 
template ndarray::Array< float, 1 > abMagErrFromFluxErr (ndarray::Array< float const, 1 > const &fluxErr, ndarray::Array< float const, 1 > const &flux)
 
template ndarray::Array< float, 1 > fluxFromABMag (ndarray::Array< float const, 1 > const &mag)
 
template ndarray::Array< float, 1 > fluxErrFromABMagErr (ndarray::Array< float const, 1 > const &magErr, ndarray::Array< float const, 1 > const &mag)
 
template ndarray::Array< double, 1 > abMagFromFlux (ndarray::Array< double const, 1 > const &flux)
 
template ndarray::Array< double, 1 > abMagErrFromFluxErr (ndarray::Array< double const, 1 > const &fluxErr, ndarray::Array< double const, 1 > const &flux)
 
template ndarray::Array< double, 1 > fluxFromABMag (ndarray::Array< double const, 1 > const &mag)
 
template ndarray::Array< double, 1 > fluxErrFromABMagErr (ndarray::Array< double const, 1 > const &magErr, ndarray::Array< double const, 1 > const &mag)
 
std::shared_ptr< FilterLabelmakeFilterLabelDirect (std::string const &name)
 
std::shared_ptr< FilterLabelmakeFilterLabel (Filter const &filter)
 
std::shared_ptr< FilterLabelmakeFilterLabel (std::string const &name)
 
Filter makeFilter (FilterLabel const &label)
 
template bool imagesOverlap< std::uint16_t, std::uint16_t > (MaskedImage< std::uint16_t > const &, MaskedImage< std::uint16_t > const &)
 
template bool imagesOverlap< std::uint16_t, int > (MaskedImage< std::uint16_t > const &, MaskedImage< int > const &)
 
template bool imagesOverlap< std::uint16_t, float > (MaskedImage< std::uint16_t > const &, MaskedImage< float > const &)
 
template bool imagesOverlap< std::uint16_t, double > (MaskedImage< std::uint16_t > const &, MaskedImage< double > const &)
 
template bool imagesOverlap< std::uint16_t, std::uint64_t > (MaskedImage< std::uint16_t > const &, MaskedImage< std::uint64_t > const &)
 
template bool imagesOverlap< int, std::uint16_t > (MaskedImage< int > const &, MaskedImage< std::uint16_t > const &)
 
template bool imagesOverlap< int, int > (MaskedImage< int > const &, MaskedImage< int > const &)
 
template bool imagesOverlap< int, float > (MaskedImage< int > const &, MaskedImage< float > const &)
 
template bool imagesOverlap< int, double > (MaskedImage< int > const &, MaskedImage< double > const &)
 
template bool imagesOverlap< int, std::uint64_t > (MaskedImage< int > const &, MaskedImage< std::uint64_t > const &)
 
template bool imagesOverlap< float, std::uint16_t > (MaskedImage< float > const &, MaskedImage< std::uint16_t > const &)
 
template bool imagesOverlap< float, int > (MaskedImage< float > const &, MaskedImage< int > const &)
 
template bool imagesOverlap< float, float > (MaskedImage< float > const &, MaskedImage< float > const &)
 
template bool imagesOverlap< float, double > (MaskedImage< float > const &, MaskedImage< double > const &)
 
template bool imagesOverlap< float, std::uint64_t > (MaskedImage< float > const &, MaskedImage< std::uint64_t > const &)
 
template bool imagesOverlap< double, std::uint16_t > (MaskedImage< double > const &, MaskedImage< std::uint16_t > const &)
 
template bool imagesOverlap< double, int > (MaskedImage< double > const &, MaskedImage< int > const &)
 
template bool imagesOverlap< double, float > (MaskedImage< double > const &, MaskedImage< float > const &)
 
template bool imagesOverlap< double, double > (MaskedImage< double > const &, MaskedImage< double > const &)
 
template bool imagesOverlap< double, std::uint64_t > (MaskedImage< double > const &, MaskedImage< std::uint64_t > const &)
 
template bool imagesOverlap< std::uint64_t, std::uint16_t > (MaskedImage< std::uint64_t > const &, MaskedImage< std::uint16_t > const &)
 
template bool imagesOverlap< std::uint64_t, int > (MaskedImage< std::uint64_t > const &, MaskedImage< int > const &)
 
template bool imagesOverlap< std::uint64_t, float > (MaskedImage< std::uint64_t > const &, MaskedImage< float > const &)
 
template bool imagesOverlap< std::uint64_t, double > (MaskedImage< std::uint64_t > const &, MaskedImage< double > const &)
 
template bool imagesOverlap< std::uint64_t, std::uint64_t > (MaskedImage< std::uint64_t > const &, MaskedImage< std::uint64_t > const &)
 
std::ostreamoperator<< (std::ostream &os, PhotoCalib const &photoCalib)
 
bool _eqOrNan (double lhs, double rhs) noexcept
 
bool _eqOrNonFinite (lsst::geom::SpherePoint const &lhs, lsst::geom::SpherePoint const &rhs) noexcept
 

Variables

 PARENT
 
 LOCAL
 
 X
 
 Y
 
class[[deprecated("Removed with no replacement (but see lsst::afw::image::TransmissionCurve). Will be " "removed after v22.")]] FilterProperty final
 
const double PixelZeroPos