Namespaces
	basicUtils

	detail

	details

	pixel

	SdssFilters

	testUtils

	utils

Classes
class	imageIterator
	An ImageBase iterator. More...

class	imageLocator
	An ImageBase locator. More...

class	Image
	A class to represent a 2-dimensional array of pixels. More...

class	WcsFactory

class	ApCorrMap
	A thin wrapper around std::map to allow aperture corrections to be attached to Exposures. More...

class	Calib

class	CoaddInputs
	A simple Persistable struct containing ExposureCatalogs that record the inputs to a coadd. More...

class	Color

class	DefectBase
	Encapsulate information about a bad portion of a detector. More...

class	DistortedTanWcs
	Combination of a TAN WCS and a distortion model. More...

class	Exposure
	A class to contain the data, WCS, and other information needed to describe an image of the sky. More...

class	ExposureInfo
	A collection of all the things that make an Exposure different from a MaskedImage. More...

class	FilterProperty

class	Filter
	Holds an integer identifier for an LSST filter. More...

class	CheckIndices
	A class used to request that array accesses be checked. More...

struct	Reference
	metafunction to extract reference type from PixelT More...

struct	ConstReference
	metafunction to extract const reference type from PixelT More...

class	ImageBase
	The base class for all image classed (Image, Mask, MaskedImage, ...) More...

class	DecoratedImage
	A container for an Image and its associated metadata. More...

struct	pixelOp0

struct	pixelOp1

struct	pixelOp1XY

struct	pixelOp2

struct	pixelOp2XY

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

struct	GetImage

class	TanWcs
	Implementation of the WCS standard for the special case of the Gnomonic (tangent plane) projection. More...

class	Wcs
	Implementation of the WCS standard for a any projection. More...

class	XYTransformFromWcsPair
	XYTransformFromWcsPair: An XYTransform obtained by putting two Wcs objects "back to back". More...

Typedefs
typedef std::uint16_t	MaskPixel

typedef float	VariancePixel
	! default type for Masks and MaskedImage Masks More...

Enumerations
enum	ImageOrigin { PARENT, LOCAL }

enum	xOrY { X, Y }

Functions
template<typename Image1T , typename Image2T >
double	innerProduct (Image1T const &lhs, Image2T const &rhs, int border)

template<typename PixelT >
void	swap (Mask< PixelT > &a, Mask< PixelT > &b)

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)
	Compute flux in Janskys from AB magnitude. More...

double	fluxErrFromABMagErr (double magErr, double mag)
	Compute flux error in Janskys from AB magnitude error and AB magnitude. More...

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >
Exposure< ImagePixelT, MaskPixelT, VariancePixelT > ::Ptr	makeExposure (MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &mimage, boost::shared_ptr< Wcs const > wcs=boost::shared_ptr< Wcs const >())

template<typename PixelT >
void	fits_read_array (fits::Fits &fitsfile, ndarray::Array< PixelT, 2, 2 > &array, geom::Point2I &xy0, lsst::daf::base::PropertySet &metadata, geom::Box2I bbox=geom::Box2I(), ImageOrigin origin=PARENT)

template<typename ImageT >
void	fits_write_image (fits::Fits &fitsfile, const ImageT &image, boost::shared_ptr< daf::base::PropertySet const > metadata=boost::shared_ptr< daf::base::PropertySet const >())

template<typename supported_fits_types , typename ImageT >
void	fits_read_image (fits::Fits &fitsfile, ImageT &img, lsst::daf::base::PropertySet &metadata, geom::Box2I const &bbox=geom::Box2I(), ImageOrigin const origin=PARENT)

template<typename supported_fits_types , typename ImageT >
void	fits_read_image (fits::Fits &fitsfile, ImageT &img, boost::shared_ptr< lsst::daf::base::PropertySet > metadata=boost::shared_ptr< lsst::daf::base::PropertySet >(), geom::Box2I const &bbox=geom::Box2I(), ImageOrigin const origin=PARENT)

template<typename PixelT >
void	swap (ImageBase< PixelT > &a, ImageBase< PixelT > &b)

template<typename LhsPixelT , typename RhsPixelT >
void	operator+= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)

template<typename LhsPixelT , typename RhsPixelT >
void	operator-= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)

template<typename LhsPixelT , typename RhsPixelT >
void	operator*= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)

template<typename LhsPixelT , typename RhsPixelT >
void	operator/= (Image< LhsPixelT > &lhs, Image< RhsPixelT > const &rhs)

template<typename PixelT >
void	swap (Image< PixelT > &a, Image< PixelT > &b)

template<typename PixelT >
void	swap (DecoratedImage< PixelT > &a, DecoratedImage< PixelT > &b)

template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp0< LhsT > const &func)

template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp1< LhsT > const &func)

template<typename LhsT >
void	for_each_pixel (Image< LhsT > &lhs, pixelOp1XY< LhsT > const &func)

template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp1< RhsT > const &func)

template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2< LhsT, RhsT > const &func)

template<typename LhsT , typename RhsT >
void	for_each_pixel (Image< LhsT > &lhs, Image< RhsT > const &rhs, pixelOp2XY< LhsT, RhsT > const &func)

template<typename PixelT >
Image< PixelT >::Ptr	operator+ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)

template<typename PixelT >
Image< PixelT >::Ptr	operator+ (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)

template<typename PixelT >
void	operator+= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator+=() More...

template<typename PixelT >
Image< PixelT >::Ptr	operator- (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)

template<typename PixelT >
void	operator-= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator-=() More...

template<typename PixelT >
Image< PixelT >::Ptr	operator* (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)

template<typename PixelT >
Image< PixelT >::Ptr	operator* (ImageSlice< PixelT > const &slc, Image< PixelT > const &img)

template<typename PixelT >
void	operator*= (Image< PixelT > &img, ImageSlice< PixelT > const &slc)
	Overload operator*=() More...

template<typename PixelT >
Image< PixelT >::Ptr	operator/ (Image< PixelT > const &img, ImageSlice< PixelT > const &slc)

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 ImagePixelT , typename MaskPixelT , typename VariancePixelT >
MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > *	makeMaskedImage (typename Image< ImagePixelT >::Ptr image, typename Mask< MaskPixelT >::Ptr mask=typename Mask< MaskPixelT >::Ptr(), typename Image< VariancePixelT >::Ptr variance=typename Image< VariancePixelT >::Ptr())

boost::shared_ptr < daf::base::PropertySet >	readMetadata (std::string const &fileName, int hdu=0, bool strip=false)
	Return the metadata (header entries) from a FITS file. More...

boost::shared_ptr< Wcs >	makeWcs (boost::shared_ptr< lsst::daf::base::PropertySet > const &fitsMetadata, bool stripMetadata=false)

boost::shared_ptr< Wcs >	makeWcs (coord::Coord const &crval, geom::Point2D const &crpix, double CD11, double CD12, double CD21, double CD22)
	Create a Wcs object from crval, crpix, CD, using CD elements (useful from python) More...

Variables
const double	PixelZeroPos = 0.0
	FITS uses 1.0, SDSS uses 0.5, LSST uses 0.0 (http://dev.lsstcorp.org/trac/wiki/BottomLeftPixelProposalII%3A) More...

Typedef Documentation

typedef std::uint16_t lsst::afw::image::MaskPixel

Definition at line 33 of file LsstImageTypes.h.

typedef float lsst::afw::image::VariancePixel

! default type for Masks and MaskedImage Masks

Definition at line 34 of file LsstImageTypes.h.

Enumeration Type Documentation

enum lsst::afw::image::ImageOrigin

Enumerator
PARENT
LOCAL

Definition at line 107 of file Image.h.

107 {PARENT, LOCAL};

lsst::afw::image::LOCAL

Definition: Image.h:107

lsst::afw::image::PARENT

Definition: Image.h:107

enum lsst::afw::image::xOrY

Enumerator
X
Y

Definition at line 40 of file ImageUtils.h.

40 {X, Y};

lsst::afw::image::X

Definition: ImageUtils.h:40

lsst::afw::image::Y

Definition: ImageUtils.h:40

Function Documentation

double lsst::afw::image::abMagErrFromFluxErr	(	double	fluxErr,
		double	flux
	)

inline

Compute AB magnitude error from flux and flux error in Janskys.

Definition at line 64 of file Calib.h.

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

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

inline

Compute AB magnitude from flux in Janskys.

Definition at line 59 of file Calib.h.

                                          {
     return -2.5*std::log10(flux/JanskysPerABFlux);
 }

template<typename PixelT >

void lsst::afw::image::fits_read_array	(	fits::Fits &	fitsfile,
		ndarray::Array< PixelT, 2, 2 > &	array,
		geom::Point2I &	xy0,
		lsst::daf::base::PropertySet &	metadata,
		geom::Box2I	bbox = `geom::Box2I()`,
		ImageOrigin	origin = `PARENT`
	)

inline

Definition at line 39 of file fits_io.h.

   {
     if (!fitsfile.checkImageType<PixelT>()) {
         throw LSST_FITS_EXCEPT(
             fits::FitsTypeError,
             fitsfile,
             "Incorrect image type for FITS image"
         );
     }
     int nAxis = fitsfile.getImageDim();
     ndarray::Vector<ndarray::Size,2> shape;
     if (nAxis == 2) {
         shape = fitsfile.getImageShape<2>();
     } else if (nAxis == 3) {
         ndarray::Vector<ndarray::Size,3> shape3 = fitsfile.getImageShape<3>();
         if (shape3[0] != 1) {
             throw LSST_EXCEPT(
                 fits::FitsError,
                 boost::str(boost::format("3rd dimension %d is not 1") % shape3[0])
             );
         }
         shape = shape3.last<2>();
     }
 
     fitsfile.readMetadata(metadata, true);
 
     // Origin of part of image to read
     xy0 = geom::Point2I();
 
     geom::Extent2I xyOffset(detail::getImageXY0FromMetadata(detail::wcsNameForXY0, &metadata));
     geom::Extent2I dimensions = geom::Extent2I(shape[1], shape[0]);
 
     if (!bbox.isEmpty()) {
         if (origin == PARENT) {
             bbox.shift(-xyOffset);
         }
         xy0 = bbox.getMin();
 
         if (bbox.getMinX() < 0 || bbox.getMinY() < 0 ||
             bbox.getWidth() > dimensions.getX() || bbox.getHeight() > dimensions.getY()
         ) {
             throw LSST_EXCEPT(
                 lsst::pex::exceptions::LengthError,
                 (boost::format("BBox (%d,%d) %dx%d doesn't fit in image %dx%d") %
                  bbox.getMinX() % bbox.getMinY() % bbox.getWidth() % bbox.getHeight() %
                  dimensions.getX() % dimensions.getY()).str()
             );
         }
         dimensions = bbox.getDimensions();
     }
 
     array = ndarray::allocate(dimensions.getY(), dimensions.getX());
 
     fitsfile.readImage(array, ndarray::makeVector(xy0.getY(), xy0.getX()));
 
     xy0 += xyOffset;
 }

template<typename supported_fits_types , typename ImageT >

void lsst::afw::image::fits_read_image	(	fits::Fits &	fitsfile,
		ImageT &	img,
		lsst::daf::base::PropertySet &	metadata,
		geom::Box2I const &	bbox = `geom::Box2I()`,
		ImageOrigin const	origin = `PARENT`
	)

Definition at line 87 of file fits_io_mpl.h.

   {
     ndarray::Array<typename ImageT::Pixel,2,2> array;
     geom::Point2I xy0;
     try {
         boost::mpl::for_each<supported_fits_types>(
             try_fits_read_array<ImageT, found_type>(
                 fitsfile, array, xy0, metadata, bbox, origin
             )
         );
     } catch (found_type &) {
         img = ImageT(array, false, xy0);
         return;
     }
     throw LSST_FITS_EXCEPT(
         fits::FitsError,
         fitsfile,
         "FITS file does not have one of the expected types"
     );
 }

template<typename supported_fits_types , typename ImageT >

void lsst::afw::image::fits_read_image	(	fits::Fits &	fitsfile,
		ImageT &	img,
		boost::shared_ptr< lsst::daf::base::PropertySet >	metadata = `boost::shared_ptr< lsst::daf::base::PropertySet >()`,
		geom::Box2I const &	bbox = `geom::Box2I()`,
		ImageOrigin const	origin = `PARENT`
	)

Definition at line 113 of file fits_io_mpl.h.

   {
     lsst::daf::base::PropertySet metadata_s;
     fits_read_image<supported_fits_types, ImageT>(fitsfile, img, (metadata ? *metadata : metadata_s),
                                                   bbox, origin);
 }

template<typename ImageT >

void lsst::afw::image::fits_write_image	(	fits::Fits &	fitsfile,
		const ImageT &	image,
		boost::shared_ptr< daf::base::PropertySet const >	metadata = `boost::shared_ptr< daf::base::PropertySet const>()`
	)

inline

Definition at line 104 of file fits_io.h.

   {
     fitsfile.createImage<typename ImageT::Pixel>(image.getArray().getShape());
     if (metadata) {
         fitsfile.writeMetadata(*metadata);
     }
     fitsfile.writeImage(image.getArray());
 }

double lsst::afw::image::fluxErrFromABMagErr	(	double	magErr,
		double	mag
	)

inline

Compute flux error in Janskys from AB magnitude error and AB magnitude.

Definition at line 74 of file Calib.h.

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

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

inline

Compute flux in Janskys from AB magnitude.

Definition at line 69 of file Calib.h.

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

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

lhs	Image to set
func	functor to call

Examples:: forEachPixel.cc.

Definition at line 103 of file ImageAlgorithm.h.

     {
         for (int y = 0; y != lhs.getHeight(); ++y) {
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++lhsPtr) {
                 *lhsPtr = func();
             }
         }
     }

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

lhs	Image to set
func	functor to call

Definition at line 119 of file ImageAlgorithm.h.

     {
         for (int y = 0; y != lhs.getHeight(); ++y) {
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++lhsPtr) {
                 *lhsPtr = func(*lhsPtr);
             }
         }
     }

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

lhs	Image to set
func	functor to call

Definition at line 137 of file ImageAlgorithm.h.

     {
         for (int y = 0; y != lhs.getHeight(); ++y) {
             int x = lhs.getX0();
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++lhsPtr, ++x) {
                 *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr);
             }
         }
     }

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

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 154 of file ImageAlgorithm.h.

     {
         if (lhs.getDimensions() != rhs.getDimensions()) {
             throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                               (boost::format("Images are of different size, %dx%d v %dx%d") %
                                lhs.getWidth() % lhs.getHeight() % rhs.getWidth() % rhs.getHeight()).str());
         }
 
         for (int y = 0; y != lhs.getHeight(); ++y) {
             typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
                 *lhsPtr = func(*rhsPtr);
             }
         }
     }

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

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 179 of file ImageAlgorithm.h.

     {
         if (lhs.getDimensions() != rhs.getDimensions()) {
             throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                               (boost::format("Images are of different size, %dx%d v %dx%d") %
                                lhs.getWidth() % lhs.getHeight() % rhs.getWidth() % rhs.getHeight()).str());
         }
 
         for (int y = 0; y != lhs.getHeight(); ++y) {
             typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
                 *lhsPtr = func(*lhsPtr, *rhsPtr);
             }
         }
     }

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

lhs	Image to set
rhs	other Image to pass to `func`
func	functor to call

Definition at line 205 of file ImageAlgorithm.h.

     {
         if (lhs.getDimensions() != rhs.getDimensions()) {
             throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                               (boost::format("Images are of different size, %dx%d v %dx%d") %
                                lhs.getWidth() % lhs.getHeight() % rhs.getWidth() % rhs.getHeight()).str());
         }
 
         for (int y = 0; y != lhs.getHeight(); ++y) {
             typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
             int x = lhs.getX0();
             for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
                  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
                 *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
             }
         }
     }

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

ind	image index

Definition at line 54 of file ImageUtils.h.

       {
         return ind + PixelZeroPos;
     }

template<typename Image1T , typename Image2T >

double lsst::afw::image::innerProduct	(	Image1T const &	lhs,
		Image2T const &	rhs,
		int	border
	)

Calculate the inner product of two images

Returns: The inner product

Exceptions

lsst::pex::exceptions::LengthError if all the images aren't the same size

Parameters

lhs	first image
rhs	Other image to dot with first
border	number of pixels to ignore around the edge

Definition at line 455 of file ImagePca.cc.

                      {
     if (lhs.getWidth() <= 2*border || lhs.getHeight() <= 2*border) {
         throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                           (boost::format("All image pixels are in the border of width %d: %dx%d") %
                            border % lhs.getWidth() % lhs.getHeight()).str());
     }
 
     double sum = 0.0;
     //
     // Handle I.I specially for efficiency, and to avoid advancing the iterator twice
     //
     if (imagesAreIdentical(lhs, rhs)) {
         for (int y = border; y != lhs.getHeight() - border; ++y) {
             for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
                      lend = lhs.row_end(y) - border; lptr != lend; ++lptr) {
                 typename Image1T::Pixel val = *lptr;
                 if (std::isfinite(val)) {
                     sum += val*val;
                 }
             }
         }
     } else {
         if (lhs.getDimensions() != rhs.getDimensions()) {
             throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                               (boost::format("Dimension mismatch: %dx%d v. %dx%d") %
                                lhs.getWidth() % lhs.getHeight() % rhs.getWidth() % rhs.getHeight()).str());
         }
 
         for (int y = border; y != lhs.getHeight() - border; ++y) {
             typename Image2T::const_x_iterator rptr = rhs.row_begin(y) + border;
             for (typename Image1T::const_x_iterator lptr = lhs.row_begin(y) + border,
                      lend = lhs.row_end(y) - border; lptr != lend; ++lptr, ++rptr) {
                 double const tmp = (*lptr)*(*rptr);
                 if (std::isfinite(tmp)) {
                     sum += tmp;
                 }
             }
         }
     }
 
     return sum;
 }

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

Exposure<ImagePixelT, MaskPixelT, VariancePixelT>::Ptr lsst::afw::image::makeExposure	(	MaskedImage< ImagePixelT, MaskPixelT, VariancePixelT > &	mimage,
		boost::shared_ptr< Wcs const >	wcs = `boost::shared_ptr< Wcs const>()`
	)

A function to return an Exposure of the correct type (cf. std::make_pair)

Parameters

mimage	the Exposure's image
wcs	the Exposure's WCS

Definition at line 306 of file Exposure.h.

   {
     return typename Exposure<ImagePixelT, MaskPixelT, VariancePixelT>::Ptr(
         new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
 }

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>* lsst::afw::image::makeMaskedImage	(	typename Image< ImagePixelT >::Ptr	image,
		typename Mask< MaskPixelT >::Ptr	mask = `typename Mask<MaskPixelT>::Ptr()`,
		typename Image< VariancePixelT >::Ptr	variance = `typename Image<VariancePixelT>::Ptr()`
	)

A function to return a MaskedImage of the correct type (cf. std::make_pair)

Parameters

image	image
mask	mask
variance	variance

Definition at line 1073 of file MaskedImage.h.

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

afwImg::Wcs::Ptr lsst::afw::image::makeWcs	(	boost::shared_ptr< lsst::daf::base::PropertySet > const &	_metadata,
		bool	stripMetadata = `false`
	)

Set stripMetadata=true to remove processed keywords from the PropertySet.

Create a Wcs object from a fits header. It examines the header and determines the most suitable object to return, either a general Wcs object, or a more specific object specialised to a given coordinate system (e.g TanWcs)

Parameters

_metadata	input metadata
stripMetadata	Remove FITS keywords from metadata?

Definition at line 40 of file makeWcs.cc.

 {
     //
     // _metadata is not const (it is probably meant to be), but we don't want to modify it.
     //
     auto metadata = _metadata;          // we'll make a copy and modify metadata if needs be
     auto modifyable = false;            // ... and set this variable to say that we did
 
     std::string ctype1, ctype2;
     if (metadata->exists("CTYPE1") && metadata->exists("CTYPE2")) {
         ctype1 = metadata->getAsString("CTYPE1");
         ctype2 = metadata->getAsString("CTYPE2");
     } else {
         return PTR(Wcs)();
     }
     //
     // SCAMP used to use PVi_j keys with a CTYPE of TAN to specify a "TPV" projection
     // (cf. https://github.com/astropy/astropy/issues/299
     // and the discussion from Dave Berry in https://jira.lsstcorp.org/browse/DM-2883)
     //
     // Follow Dave's AST and switch TAN to TPV
     //
     if (ctype1.substr(5, 3) == "TAN" &&
         (metadata->exists("PV1_5") || metadata->exists("PV2_1"))) {
         LOGL_INFO("makeWcs", "Interpreting %s/%s + PVi_j as TPV", ctype1.c_str(), ctype2.c_str());
 
         if (!modifyable) {
             metadata = _metadata->deepCopy();
             modifyable = true;
         }
 
         ctype1.replace(5, 3, "TPV");
         metadata->set<std::string>("CTYPE1", ctype1);
 
         ctype2.replace(5, 3, "TPV");
         metadata->set<std::string>("CTYPE2", ctype2);
     }
 
     afwImg::Wcs::Ptr wcs;               // we can't use make_shared as ctor is private
     if (ctype1.substr(5, 3) == "TAN") {
         wcs = afwImg::Wcs::Ptr(new afwImg::TanWcs(metadata));
     } else if (ctype1.substr(5, 3) == "TPV") { // unfortunately we don't support TPV
         if (!modifyable) {
             metadata = _metadata->deepCopy();
             modifyable = true;
         }
 
         LOGL_WARN("makeWcs", "Stripping PVi_j keys from projection %s/%s", ctype1.c_str(), ctype2.c_str());
 
         metadata->set<std::string>("CTYPE1", "RA---TAN");
         metadata->set<std::string>("CTYPE2", "DEC--TAN");
         metadata->set<bool>("TPV_WCS", true);
         // PV1_[1-4] are in principle legal, although Swarp reuses them as part of the TPV parameterisation.
         // It turns out that leaving PV1_[1-4] in the header breaks wcslib 4.14's ability to read
         // DECam headers (DM-3196) so we'll delete them all for now.
         //
         // John Swinbank points out the maximum value of j in TVi_j is 39;
         // http://fits.gsfc.nasa.gov/registry/tpvwcs/tpv.html
         for (int i = 0; i != 2; ++i) {
             for (int j = 1; j <= 39; ++j) { // 39's the max in the TPV standard
                 char pvName[8];
                 sprintf(pvName, "PV%d_%d", i, j);
                 if (metadata->exists(pvName)) {
                     metadata->remove(pvName);
                 }
             }
         }
 
         wcs = afwImg::Wcs::Ptr(new afwImg::TanWcs(metadata));
     } else {
         wcs = afwImg::Wcs::Ptr(new afwImg::Wcs(metadata));
     }
 
     //If keywords LTV[1,2] are present, the image on disk is already a subimage, so
     //we should shift the wcs to allow for this.
     std::string key = "LTV1";
     if (metadata->exists(key)) {
         wcs->shiftReferencePixel(-metadata->getAsDouble(key), 0);
     }
 
     key = "LTV2";
     if (metadata->exists(key) ) {
         wcs->shiftReferencePixel(0, -metadata->getAsDouble(key));
     }
 
     if (stripMetadata) {
         afwImg::detail::stripWcsKeywords(metadata, wcs);
     }
 
     return wcs;
 }

afwImg::Wcs::Ptr lsst::afw::image::makeWcs	(	coord::Coord const &	crval,
		geom::Point2D const &	crpix,
		double	CD11,
		double	CD12,
		double	CD21,
		double	CD22
	)

Create a Wcs object from crval, crpix, CD, using CD elements (useful from python)

Parameters

crval	CRVAL1,2 (ie. the sky origin)
crpix	CRPIX1,2 (ie. the pixel origin) in pixels
CD11	CD matrix element 1,1
CD12	CD matrix element 1,2
CD21	CD matrix element 2,1
CD22	CD matrix element 2,2

Definition at line 138 of file makeWcs.cc.

       {
     Eigen::Matrix2d CD;
     CD << CD11, CD12, CD21, CD22;
     lsst::afw::geom::Point2D crvalTmp;
     crvalTmp[0] = crval.toIcrs().getLongitude().asDegrees();
     crvalTmp[1] = crval.toIcrs().getLatitude().asDegrees();
     return afwImg::Wcs::Ptr(new lsst::afw::image::TanWcs(crvalTmp, crpix, CD));
 }

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator*	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator*	(	ImageSlice< PixelT > const &	slc,
		Image< PixelT > const &	img
	)

template<typename PixelT >

void lsst::afw::image::operator*=	(	afwImage::Image< PixelT > &	img,
		afwImage::ImageSlice< PixelT > const &	slc
	)

Overload operator*=()

Only 'image *= slice' is defined, as 'slice *= image' doesn't make sense.

Parameters

img	The Image
slc	The ImageSlice

Definition at line 204 of file ImageSlice.cc.

                            {
     details::operate<details::Mult<PixelT> >(img, slc, slc.getImageSliceType());
 }

template<typename LhsPixelT , typename RhsPixelT >

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

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

Definition at line 878 of file Image.cc.

                                                                                    {
     image::for_each_pixel(lhs, rhs, timesEq<LhsPixelT, RhsPixelT>());
 }

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator+	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator+	(	ImageSlice< PixelT > const &	slc,
		Image< PixelT > const &	img
	)

template<typename PixelT >

void lsst::afw::image::operator+=	(	afwImage::Image< PixelT > &	img,
		afwImage::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

img	The Image
slc	The ImageSlice

Definition at line 121 of file ImageSlice.cc.

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

template<typename LhsPixelT , typename RhsPixelT >

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

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

Definition at line 864 of file Image.cc.

                                                                                    {
     image::for_each_pixel(lhs, rhs, plusEq<LhsPixelT, RhsPixelT>());
 }

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator-	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

template<typename PixelT >

void lsst::afw::image::operator-=	(	afwImage::Image< PixelT > &	img,
		afwImage::ImageSlice< PixelT > const &	slc
	)

Overload operator-=()

Only 'image -= slice' is defined. 'slice -= image' wouldn't make sense.

Parameters

img	The Image
slc	The ImageSlice

Definition at line 157 of file ImageSlice.cc.

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

template<typename LhsPixelT , typename RhsPixelT >

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

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

Definition at line 871 of file Image.cc.

                                                                                    {
     image::for_each_pixel(lhs, rhs, minusEq<LhsPixelT, RhsPixelT>());
 }

template<typename PixelT >

Image<PixelT>::Ptr lsst::afw::image::operator/	(	Image< PixelT > const &	img,
		ImageSlice< PixelT > const &	slc
	)

template<typename PixelT >

void lsst::afw::image::operator/=	(	afwImage::Image< PixelT > &	img,
		afwImage::ImageSlice< PixelT > const &	slc
	)

Overload operator/=()

Only 'image /= slice' is defined, as 'slice /= image' doesn't make sense.

Parameters

img	The Image
slc	The ImageSlice

Definition at line 240 of file ImageSlice.cc.

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

template<typename LhsPixelT , typename RhsPixelT >

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

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

Definition at line 885 of file Image.cc.

                                                                                    {
     image::for_each_pixel(lhs, rhs, divideEq<LhsPixelT, RhsPixelT>());
 }

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

pos	image position

Definition at line 69 of file ImageUtils.h.

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

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

residual	fractional part of index
pos	image position

Definition at line 86 of file ImageUtils.h.

       {
         double fullIndex = pos - PixelZeroPos;
         double roundedIndex = std::floor(fullIndex + 0.5);
         residual = fullIndex - roundedIndex;
         return static_cast<int>(roundedIndex);
     }

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

pos	image position

Definition at line 100 of file ImageUtils.h.

       {
         double residual;                // fractional part of index
         int const ind = positionToIndex(residual, pos); // integral part
 
         return std::pair<int, double>(ind, residual);
     }

boost::shared_ptr< daf::base::PropertySet > lsst::afw::image::readMetadata	(	std::string const &	fileName,
		int	hdu = `0`,
		bool	strip = `false`
	)

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

Parameters

[in]	fileName	File to read.
[in]	hdu	HDU to read, 1-indexed. The special value of 0 will read the first non-empty HDU.
[in]	strip	If true, ignore special header keys usually managed by cfitsio (e.g. NAXIS).

template<typename PixelT >

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

Definition at line 315 of file Image.cc.

                                                            {
     a.swap(b);
 }

template<typename PixelT >

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

Definition at line 524 of file Mask.cc.

                                             {
     a.swap(b);
 }

template<typename PixelT >

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

Definition at line 637 of file Image.cc.

                                                    {
     a.swap(b);
 }

template<typename PixelT >

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

Definition at line 120 of file DecoratedImage.cc.

                                                                      {
     a.swap(b);
 }

Variable Documentation

const double lsst::afw::image::PixelZeroPos = 0.0

FITS uses 1.0, SDSS uses 0.5, LSST uses 0.0 (http://dev.lsstcorp.org/trac/wiki/BottomLeftPixelProposalII%3A)

position of center of pixel 0

Definition at line 42 of file ImageUtils.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation