lsst.meas.astrom g51277c4d12+ed7907e89c
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
lsst::afw::image Namespace Reference

Namespaces

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

Classes

class  ApCorrMap
 
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
 

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 >())
 
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 (std::string const &name)
 
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
 
const double PixelZeroPos