lsst::afw::geom Namespace Reference

Namespaces
	detail
	details
	ellipses
	polygon
	python
	skyWcs
	testUtils
	transform
	transformConfig
	transformFromString
	utils
	wcsUtils

Classes
class	BaseEndpoint
	Virtual base class for endpoints, which are helper classes for Transform. More...
class	BaseVectorEndpoint
	Base class for endpoints with Array = std::vector<Point> where Point has 2 dimensions. More...
class	GenericEndpoint
	A generic endpoint for data in the format used by ast::Mapping. More...
class	Point2Endpoint
	An endpoint for lsst::geom::Point2D. More...
class	SipApproximation
	A fitter and results class for approximating a general Transform in a form compatible with FITS WCS persistence. More...
class	SkyWcs
	A 2-dimensional celestial WCS that transform pixels to ICRS RA/Dec, using the LSST standard for pixels. More...
class	Span
	A range of pixels within one row of an Image. More...
class	SpanPixelIterator
	An iterator that yields lsst::geom::Point2I and increases in the x direction. More...
class	SpanSet
	A compact representation of a collection of pixels. More...
class	SpherePointEndpoint
	An endpoint for lsst::geom::SpherePoint. More...
class	Transform
	Transform LSST spatial data, such as lsst::geom::Point2D and lsst::geom::SpherePoint, using an AST mapping. More...

Typedefs
using	TransformPoint2ToPoint2 = Transform< Point2Endpoint, Point2Endpoint >
using	TransformPoint2ToGeneric = Transform< Point2Endpoint, GenericEndpoint >
using	TransformPoint2ToSpherePoint = Transform< Point2Endpoint, SpherePointEndpoint >

Enumerations
enum	Stencil { Stencil::CIRCLE, Stencil::BOX, Stencil::MANHATTAN }
	An enumeration class which describes the shapes. More...

Functions
std::ostream &	operator<< (std::ostream &os, GenericEndpoint const &endpoint)
	Print "GenericEndpoint(_n_)" to the ostream where _n_ is the number of axes, e.g. "GenericAxes(4)". More...
std::ostream &	operator<< (std::ostream &os, Point2Endpoint const &endpoint)
	Print "Point2Endpoint()" to the ostream. More...
std::ostream &	operator<< (std::ostream &os, SpherePointEndpoint const &endpoint)
	Print "SpherePointEndpoint()" to the ostream. More...
Eigen::Matrix2d	makeCdMatrix (lsst::geom::Angle const &scale, lsst::geom::Angle const &orientation=0 *lsst::geom::degrees, bool flipX=false)
	Make a WCS CD matrix. More...
std::shared_ptr< SkyWcs >	makeFlippedWcs (SkyWcs const &wcs, bool flipLR, bool flipTB, lsst::geom::Point2D const &center)
	Return a copy of a FITS-WCS with pixel positions flipped around a specified center. More...
std::shared_ptr< SkyWcs >	makeModifiedWcs (TransformPoint2ToPoint2 const &pixelTransform, SkyWcs const &wcs, bool modifyActualPixels)
	Create a new SkyWcs whose pixels are transformed by pixelTransform, as described below. More...
std::shared_ptr< SkyWcs >	makeSkyWcs (daf::base::PropertySet &metadata, bool strip=false)
	Construct a SkyWcs from FITS keywords. More...
std::shared_ptr< SkyWcs >	makeSkyWcs (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, std::string const &projection="TAN")
	Construct a simple FITS SkyWcs with no distortion. More...
std::shared_ptr< SkyWcs >	makeSkyWcs (TransformPoint2ToPoint2 const &pixelsToFieldAngle, lsst::geom::Angle const &orientation, bool flipX, lsst::geom::SpherePoint const &boresight, std::string const &projection="TAN")
	Construct a FITS SkyWcs from camera geometry. More...
std::shared_ptr< SkyWcs >	makeTanSipWcs (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, Eigen::MatrixXd const &sipA, Eigen::MatrixXd const &sipB)
	Construct a TAN-SIP SkyWcs with forward SIP distortion terms and an iterative inverse. More...
std::shared_ptr< SkyWcs >	makeTanSipWcs (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, Eigen::MatrixXd const &sipA, Eigen::MatrixXd const &sipB, Eigen::MatrixXd const &sipAp, Eigen::MatrixXd const &sipBp)
	Construct a TAN WCS with forward and inverse SIP distortion terms. More...
std::shared_ptr< TransformPoint2ToPoint2 >	makeWcsPairTransform (SkyWcs const &src, SkyWcs const &dst)
	A Transform obtained by putting two SkyWcs objects "back to back". More...
std::shared_ptr< TransformPoint2ToSpherePoint >	getIntermediateWorldCoordsToSky (SkyWcs const &wcs, bool simplify=true)
	Return a transform from intermediate world coordinates to sky. More...
std::shared_ptr< TransformPoint2ToPoint2 >	getPixelToIntermediateWorldCoords (SkyWcs const &wcs, bool simplify=true)
	Return a transform from pixel coordinates to intermediate world coordinates. More...
std::ostream &	operator<< (std::ostream &os, SkyWcs const &wcs)
	Print a SkyWcs to an ostream (delegates to SkyWcs.toString()). More...
template<class FromEndpoint , class ToEndpoint >
std::ostream &	operator<< (std::ostream &os, Transform< FromEndpoint, ToEndpoint > const &transform)
	Print a Transform to an ostream. More...
lsst::geom::AffineTransform	linearizeTransform (TransformPoint2ToPoint2 const &original, lsst::geom::Point2D const &inPoint)
	Approximate a Transform by its local linearization. More...
std::shared_ptr< TransformPoint2ToPoint2 >	makeTransform (lsst::geom::AffineTransform const &affine)
	Wrap an lsst::geom::AffineTransform as a Transform. More...
std::shared_ptr< TransformPoint2ToPoint2 >	makeRadialTransform (std::vector< double > const &coeffs)
	A purely radial polynomial distortion. More...
std::shared_ptr< TransformPoint2ToPoint2 >	makeRadialTransform (std::vector< double > const &forwardCoeffs, std::vector< double > const &inverseCoeffs)
	A purely radial polynomial distortion. More...
std::shared_ptr< TransformPoint2ToPoint2 >	makeIdentityTransform ()
	Trivial Transform x → x. More...
std::shared_ptr< daf::base::PropertyList >	createTrivialWcsMetadata (std::string const &wcsName, lsst::geom::Point2I const &xy0)
void	deleteBasicWcsMetadata (daf::base::PropertySet &metadata, std::string const &wcsName)
Eigen::Matrix2d	getCdMatrixFromMetadata (daf::base::PropertySet &metadata)
	Read a CD matrix from FITS WCS metadata. More...
lsst::geom::Point2I	getImageXY0FromMetadata (daf::base::PropertySet &metadata, std::string const &wcsName, bool strip=false)
Eigen::MatrixXd	getSipMatrixFromMetadata (daf::base::PropertySet const &metadata, std::string const &name)
bool	hasSipMatrix (daf::base::PropertySet const &metadata, std::string const &name)
std::shared_ptr< daf::base::PropertyList >	makeSipMatrixMetadata (Eigen::MatrixXd const &matrix, std::string const &name)
std::shared_ptr< daf::base::PropertyList >	makeSimpleWcsMetadata (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, std::string const &projection="TAN")
	Make FITS metadata for a simple FITS WCS (one with no distortion). More...
std::shared_ptr< daf::base::PropertyList >	makeTanSipMetadata (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, Eigen::MatrixXd const &sipA, Eigen::MatrixXd const &sipB)
	Make metadata for a TAN-SIP WCS without inverse matrices. More...
std::shared_ptr< daf::base::PropertyList >	makeTanSipMetadata (lsst::geom::Point2D const &crpix, lsst::geom::SpherePoint const &crval, Eigen::Matrix2d const &cdMatrix, Eigen::MatrixXd const &sipA, Eigen::MatrixXd const &sipB, Eigen::MatrixXd const &sipAp, Eigen::MatrixXd const &sipBp)
	Make metadata for a TAN-SIP WCS. More...
	PYBIND11_MODULE (spanSet, mod)
template void	SpanSet::setImage< std::uint16_t > (image::Image< std::uint16_t > &image, std::uint16_t val, lsst::geom::Box2I const &region=lsst::geom::Box2I(), bool doClip=false) const
template void	SpanSet::setImage< std::uint64_t > (image::Image< std::uint64_t > &image, std::uint64_t val, lsst::geom::Box2I const &region=lsst::geom::Box2I(), bool doClip=false) const
template void	SpanSet::setMask< image::MaskPixel > (image::Mask< image::MaskPixel > &target, image::MaskPixel bitmask) const
template void	SpanSet::clearMask< image::MaskPixel > (image::Mask< image::MaskPixel > &target, image::MaskPixel bitmask) const
template std::shared_ptr< SpanSet >	SpanSet::intersect< image::MaskPixel > (image::Mask< image::MaskPixel > const &other, image::MaskPixel bitmask) const
template std::shared_ptr< SpanSet >	SpanSet::intersectNot< image::MaskPixel > (image::Mask< image::MaskPixel > const &other, image::MaskPixel bitmask) const
template std::shared_ptr< SpanSet >	SpanSet::union_< image::MaskPixel > (image::Mask< image::MaskPixel > const &other, image::MaskPixel bitmask) const
template std::ostream &	operator<<< GenericEndpoint, GenericEndpoint > (std::ostream &os, Transform< GenericEndpoint, GenericEndpoint > const &transform)
template std::ostream &	operator<<< GenericEndpoint, Point2Endpoint > (std::ostream &os, Transform< GenericEndpoint, Point2Endpoint > const &transform)
template std::ostream &	operator<<< GenericEndpoint, SpherePointEndpoint > (std::ostream &os, Transform< GenericEndpoint, SpherePointEndpoint > const &transform)
template std::ostream &	operator<<< Point2Endpoint, GenericEndpoint > (std::ostream &os, Transform< Point2Endpoint, GenericEndpoint > const &transform)
template std::ostream &	operator<<< Point2Endpoint, Point2Endpoint > (std::ostream &os, Transform< Point2Endpoint, Point2Endpoint > const &transform)
template std::ostream &	operator<<< Point2Endpoint, SpherePointEndpoint > (std::ostream &os, Transform< Point2Endpoint, SpherePointEndpoint > const &transform)
template std::ostream &	operator<<< SpherePointEndpoint, GenericEndpoint > (std::ostream &os, Transform< SpherePointEndpoint, GenericEndpoint > const &transform)
template std::ostream &	operator<<< SpherePointEndpoint, Point2Endpoint > (std::ostream &os, Transform< SpherePointEndpoint, Point2Endpoint > const &transform)
template std::ostream &	operator<<< SpherePointEndpoint, SpherePointEndpoint > (std::ostream &os, Transform< SpherePointEndpoint, SpherePointEndpoint > const &transform)

Variables
	AffineTransform
	Angle
	AngleUnit
	Box2D
	Box2I
	BoxD
	BoxI
	CoordinateExpr
	CoordinateExpr2
	CoordinateExpr3
	Extent
	Extent2D
	Extent2I
	Extent3D
	Extent3I
	ExtentBase2D
	ExtentBase2I
	ExtentBase3D
	ExtentBase3I = deprecate_pybind11(ExtentBase3I, reason="Replaced by lsst.geom.ExtentBase3I (will be removed before the release of v20.0)")
	ExtentD
	ExtentI
	LinearTransform
	Point
	Point2D
	Point2I
	Point3D
	Point3I
	PointBase2D
	PointBase2I
	PointBase3D = deprecate_pybind11(PointBase3D, reason="Replaced by lsst.geom.PointBase3D (will be removed before the release of v20.0)")
	PointBase3I
	PointD
	PointI
	SpherePoint
	arcsecToRad
	averageSpherePoint
	degToRad
	isAngle
	makeAffineTransformFromTriple
	masToRad
	radToArcsec
	radToDeg
	radToMas

Typedef Documentation

TransformPoint2ToGeneric

using lsst::afw::geom::TransformPoint2ToGeneric = typedef Transform<Point2Endpoint, GenericEndpoint>

Definition at line 301 of file Transform.h.

TransformPoint2ToPoint2

using lsst::afw::geom::TransformPoint2ToPoint2 = typedef Transform<Point2Endpoint, Point2Endpoint>

Definition at line 300 of file Transform.h.

TransformPoint2ToSpherePoint

using lsst::afw::geom::TransformPoint2ToSpherePoint = typedef Transform<Point2Endpoint, SpherePointEndpoint>

Definition at line 302 of file Transform.h.

Enumeration Type Documentation

Stencil

enum lsst::afw::geom::Stencil

strong

An enumeration class which describes the shapes.

A stencil is a shape used in creating SpanSets, erosion kernels, or dilation kernels. CIRCLE creates a circle shape, BOX creates a box shape, and MANHATTAN creates a diamond shape.

Enumerator
CIRCLE
BOX
MANHATTAN

Definition at line 66 of file SpanSet.h.

{ CIRCLE, BOX, MANHATTAN };

Function Documentation

createTrivialWcsMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::createTrivialWcsMetadata	(	std::string const &	wcsName,
		lsst::geom::Point2I const &	xy0
	)

Definition at line 51 of file wcsUtils.cc.

                                                                                              {
    std::shared_ptr<daf::base::PropertyList> wcsMetaData(new daf::base::PropertyList);

    wcsMetaData->set("CTYPE1" + wcsName, "LINEAR", "Type of projection");
    wcsMetaData->set("CTYPE2" + wcsName, "LINEAR", "Type of projection");
    wcsMetaData->set("CRPIX1" + wcsName, static_cast<double>(1), "Column Pixel Coordinate of Reference");
    wcsMetaData->set("CRPIX2" + wcsName, static_cast<double>(1), "Row Pixel Coordinate of Reference");
    wcsMetaData->set("CRVAL1" + wcsName, static_cast<double>(xy0[0]), "Column pixel of Reference Pixel");
    wcsMetaData->set("CRVAL2" + wcsName, static_cast<double>(xy0[1]), "Row pixel of Reference Pixel");
    wcsMetaData->set("CUNIT1" + wcsName, "PIXEL", "Column unit");
    wcsMetaData->set("CUNIT2" + wcsName, "PIXEL", "Row unit");

    return wcsMetaData;
}

deleteBasicWcsMetadata()

void lsst::afw::geom::deleteBasicWcsMetadata	(	daf::base::PropertySet &	metadata,
		std::string const &	wcsName
	)

Definition at line 67 of file wcsUtils.cc.

                                                                                    {
    std::vector<std::string> const names = {"CRPIX1", "CRPIX2", "CRVAL1", "CRVAL2", "CTYPE1",
                                            "CTYPE2", "CUNIT1", "CUNIT2", "CD1_1",  "CD1_2",
                                            "CD2_1",  "CD2_2",  "WCSAXES"};
    for (auto const& name : names) {
        if (metadata.exists(name + wcsName)) {
            metadata.remove(name + wcsName);
        }
    }
}

getCdMatrixFromMetadata()

Eigen::Matrix2d lsst::afw::geom::getCdMatrixFromMetadata

(

daf::base::PropertySet &

metadata

)

Read a CD matrix from FITS WCS metadata.

The elements of the returned matrix are in degrees

Exceptions

pex::exceptions::TypeError

if no CD matrix coefficients found (missing coefficients are set to 0, as usual, but they cannot all be missing).

Definition at line 78 of file wcsUtils.cc.

                                                                    {
    Eigen::Matrix2d matrix;
    bool found{false};
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            std::string const cardName = "CD" + std::to_string(i + 1) + "_" + std::to_string(j + 1);
            if (metadata.exists(cardName)) {
                matrix(i, j) = metadata.getAsDouble(cardName);
                found = true;
            } else {
                matrix(i, j) = 0.0;
            }
        }
    }
    if (!found) {
        throw LSST_EXCEPT(pex::exceptions::TypeError, "No CD matrix coefficients found");
    }
    return matrix;
}

getImageXY0FromMetadata()

lsst::geom::Point2I lsst::afw::geom::getImageXY0FromMetadata	(	daf::base::PropertySet &	metadata,
		std::string const &	wcsName,
		bool	strip = false
	)

Definition at line 98 of file wcsUtils.cc.

                                                        {
    int x0 = 0;  // Our value of X0
    int y0 = 0;  // Our value of Y0

    if (metadata.exists("CRPIX1" + wcsName) && metadata.exists("CRPIX2" + wcsName) &&
        metadata.exists("CRVAL1" + wcsName) && metadata.exists("CRVAL2" + wcsName) &&
        (metadata.getAsDouble("CRPIX1" + wcsName) == 1.0) &&
        (metadata.getAsDouble("CRPIX2" + wcsName) == 1.0)) {
        x0 = static_cast<int>(std::lround(metadata.getAsDouble("CRVAL1" + wcsName)));
        y0 = static_cast<int>(std::lround(metadata.getAsDouble("CRVAL2" + wcsName)));
        if (strip) {
            deleteBasicWcsMetadata(metadata, wcsName);
        }
    }
    return lsst::geom::Point2I(x0, y0);
}

getIntermediateWorldCoordsToSky()

std::shared_ptr< TransformPoint2ToSpherePoint > lsst::afw::geom::getIntermediateWorldCoordsToSky	(	SkyWcs const &	wcs,
		bool	simplify = true
	)

Return a transform from intermediate world coordinates to sky.

Definition at line 538 of file SkyWcs.cc.

                                                                                             {
    auto iwcToSky = wcs.getFrameDict()->getMapping("IWC", "SKY");
    return std::make_shared<TransformPoint2ToSpherePoint>(*iwcToSky, simplify);
}

getPixelToIntermediateWorldCoords()

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::getPixelToIntermediateWorldCoords	(	SkyWcs const &	wcs,
		bool	simplify = true
	)

Return a transform from pixel coordinates to intermediate world coordinates.

The pixel frame is is the base frame: cameraGeom::ACTUAL_PIXELS, if present, else cameraGeom::PIXELS.

Definition at line 544 of file SkyWcs.cc.

                                                                                                           {
    auto pixelToIwc = wcs.getFrameDict()->getMapping(ast::FrameSet::BASE, "IWC");
    return std::make_shared<TransformPoint2ToPoint2>(*pixelToIwc, simplify);
}

getSipMatrixFromMetadata()

Eigen::MatrixXd lsst::afw::geom::getSipMatrixFromMetadata	(	daf::base::PropertySet const &	metadata,
		std::string const &	name
	)

Definition at line 116 of file wcsUtils.cc.

                                                                                                  {
    std::string cardName = name + "_ORDER";
    if (!metadata.exists(cardName)) {
        throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                          "metadata does not contain SIP matrix " + name + ": " + cardName + " not found");
    };
    int order = metadata.getAsInt(cardName);
    if (order < 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                          "matrix order = " + std::to_string(order) + " < 0");
    }
    Eigen::MatrixXd matrix(order + 1, order + 1);
    auto const coeffName = name + "_";
    for (int i = 0; i <= order; ++i) {
        for (int j = 0; j <= order; ++j) {
            std::string const cardName = getSipCoeffCardName(coeffName, i, j);
            if (metadata.exists(cardName)) {
                matrix(i, j) = metadata.getAsDouble(cardName);
            } else {
                matrix(i, j) = 0.0;
            }
        }
    }
    return matrix;
}

hasSipMatrix()

bool lsst::afw::geom::hasSipMatrix	(	daf::base::PropertySet const &	metadata,
		std::string const &	name
	)

Definition at line 142 of file wcsUtils.cc.

                                                                             {
    std::string cardName = name + "_ORDER";
    if (!metadata.exists(cardName)) {
        return false;
    }
    return metadata.getAsInt(cardName) >= 0;
}

linearizeTransform()

lsst::geom::AffineTransform lsst::afw::geom::linearizeTransform	(	TransformPoint2ToPoint2 const &	original,
		lsst::geom::Point2D const &	inPoint
	)

Approximate a Transform by its local linearization.

Template Parameters

FromEndpoint,ToEndpoint

The endpoints of the transform.

Parameters

original	the Transform to linearize
inPoint	the point at which a linear approximation is desired

Returns

an lsst::geom::AffineTransform whose value and Jacobian at inPoint match those of original. It may be invertible; in general, linearizations are invertible if the Jacobian at inPoint is invertible.

Exceptions

pex::exceptions::InvalidParameterError

Thrown if original does not have a well-defined value and Jacobian at inPoint

Exception Safety

Not exception safe.

Definition at line 132 of file transformFactory.cc.

                                                                               {
    auto outPoint = original.applyForward(inPoint);
    Eigen::Matrix2d jacobian = original.getJacobian(inPoint);
    for (int i = 0; i < 2; ++i) {
        if (!std::isfinite(outPoint[i])) {
            std::ostringstream buffer;
            buffer << "Transform ill-defined: " << inPoint << " -> " << outPoint;
            throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, buffer.str());
        }
    }
    if (!jacobian.allFinite()) {
        std::ostringstream buffer;
        buffer << "Transform not continuous at " << inPoint << ": J = " << jacobian;
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, buffer.str());
    }

    // y(x) = J (x - x0) + y0 = J x + (y0 - J x0)
    auto offset = outPoint.asEigen() - jacobian * inPoint.asEigen();
    return lsst::geom::AffineTransform(jacobian, offset);
}

makeCdMatrix()

Eigen::Matrix2d lsst::afw::geom::makeCdMatrix	(	lsst::geom::Angle const &	scale,
		lsst::geom::Angle const &	orientation = 0 * lsst::geom::degrees,
		bool	flipX = false
	)

Make a WCS CD matrix.

Parameters

[in]	scale	Pixel scale as an angle on sky/pixels
[in]	orientation	Position angle of pixel +Y, measured from N through E. At 0 degrees, +Y is along N and +X is along W/E if flipX false/true At 90 degrees, +Y is along E and +X is along N/S if flipX false/true
[in]	flipX	Flip x axis? See orientation for details.

Returns

the CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]

Definition at line 138 of file SkyWcs.cc.

                                         {
    Eigen::Matrix2d cdMatrix;
    double orientRad = orientation.asRadians();
    double scaleDeg = scale.asDegrees();
    double xmult = flipX ? 1.0 : -1.0;
    cdMatrix(0, 0) = std::cos(orientRad) * scaleDeg * xmult;
    cdMatrix(0, 1) = std::sin(orientRad) * scaleDeg;
    cdMatrix(1, 0) = -std::sin(orientRad) * scaleDeg * xmult;
    cdMatrix(1, 1) = std::cos(orientRad) * scaleDeg;
    return cdMatrix;
}

makeFlippedWcs()

std::shared_ptr< SkyWcs > lsst::afw::geom::makeFlippedWcs	(	SkyWcs const &	wcs,
		bool	flipLR,
		bool	flipTB,
		lsst::geom::Point2D const &	center
	)

Return a copy of a FITS-WCS with pixel positions flipped around a specified center.

Parameters

[in]	wcs	The initial WCS
[in]	flipLR	Flip pixel positions left/right about center
[in]	flipTB	Flip pixel positions top/bottom about center
[in]	center	Center pixel position of flip

Definition at line 452 of file SkyWcs.cc.

                                                                      {
    double const dx = 1000;  // any "reasonable" number of pixels will do
    std::vector<double> inLL = {center[0] - dx, center[1] - dx};
    std::vector<double> inUR = {center[0] + dx, center[1] + dx};
    std::vector<double> outLL(inLL);
    std::vector<double> outUR(inUR);
    if (flipLR) {
        outLL[0] = inUR[0];
        outUR[0] = inLL[0];
    }
    if (flipTB) {
        outLL[1] = inUR[1];
        outUR[1] = inLL[1];
    }
    auto const flipPix = TransformPoint2ToPoint2(ast::WinMap(inLL, inUR, outLL, outUR));
    return makeModifiedWcs(flipPix, wcs, true);
}

makeIdentityTransform()

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::makeIdentityTransform

(

)

Trivial Transform x → x.

Returns

a Transform mapping any lsst::geom::Point2D to itself. The Transform's inverse shall be itself.

Exception Safety

Provides basic exception safety.

Definition at line 214 of file transformFactory.cc.

                                                               {
    return std::make_shared<TransformPoint2ToPoint2>(ast::UnitMap(2));
}

makeModifiedWcs()

std::shared_ptr< SkyWcs > lsst::afw::geom::makeModifiedWcs	(	TransformPoint2ToPoint2 const &	pixelTransform,
		SkyWcs const &	wcs,
		bool	modifyActualPixels
	)

Create a new SkyWcs whose pixels are transformed by pixelTransform, as described below.

If modifyActualPixels is true and the cameraGeom::ACTUAL_PIXELS frame exists then pixelTransform is inserted just after the cameraGeom::ACTUAL_PIXELS frame:

newActualPixelsToPixels = pixelTransform -> oldActualPixelsToPixels

This is appropriate for shifting a WCS, e.g. when writing FITS metadata for a subimage.

If modifyActualPixels is false or the cameraGeom::ACTUAL_PIXELS frame does not exist then pixelTransform is inserted just after the cameraGeom::PIXELS frame:

newPixelsToIwc = pixelTransform -> oldPixelsToIwc

This is appropriate for inserting a model for optical distortion.

Other than the change described above, the new SkyWcs will be just like the old one.

Parameters

[in]	pixelTransform	Transform to insert
[in]	wcs	Input WCS
[in]	modifyActualPixels	Location at which to insert the transform; if true and the cameraGeom::ACTUAL_PIXELS frame is present then insert just after the cameraGeom::ACTUAL_PIXELS frame, else insert just after the cameraGeom::PIXELS frame.

Returns

the new WCS

Definition at line 471 of file SkyWcs.cc.

                                                                 {
    auto const pixelMapping = pixelTransform.getMapping();
    auto oldFrameDict = wcs.getFrameDict();
    bool const hasActualPixels = oldFrameDict->hasDomain("ACTUAL_PIXELS");
    auto const pixelFrame = oldFrameDict->getFrame("PIXELS", false);
    auto const iwcFrame = oldFrameDict->getFrame("IWC", false);
    auto const skyFrame = oldFrameDict->getFrame("SKY", false);
    auto const oldPixelToIwc = oldFrameDict->getMapping("PIXELS", "IWC");
    auto const iwcToSky = oldFrameDict->getMapping("IWC", "SKY");

    std::shared_ptr<ast::FrameDict> newFrameDict;
    std::shared_ptr<ast::Mapping> newPixelToIwc;
    if (hasActualPixels) {
        auto const actualPixelFrame = oldFrameDict->getFrame("ACTUAL_PIXELS", false);
        auto const oldActualPixelToPixels = oldFrameDict->getMapping("ACTUAL_PIXELS", "PIXELS");
        std::shared_ptr<ast::Mapping> newActualPixelsToPixels;
        if (modifyActualPixels) {
            newActualPixelsToPixels = pixelMapping->then(*oldActualPixelToPixels).simplified();
            newPixelToIwc = oldPixelToIwc;
        } else {
            newActualPixelsToPixels = oldActualPixelToPixels;
            newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplified();
        }
        newFrameDict =
                std::make_shared<ast::FrameDict>(*actualPixelFrame, *newActualPixelsToPixels, *pixelFrame);
        newFrameDict->addFrame("PIXELS", *newPixelToIwc, *iwcFrame);
    } else {
        newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplified();
        newFrameDict = std::make_shared<ast::FrameDict>(*pixelFrame, *newPixelToIwc, *iwcFrame);
    }
    newFrameDict->addFrame("IWC", *iwcToSky, *skyFrame);
    return std::make_shared<SkyWcs>(*newFrameDict);
}

makeRadialTransform() [1/2]

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::makeRadialTransform

(

std::vector< double > const &

coeffs

)

A purely radial polynomial distortion.

The Transform transforms an input \(x\) to

\[ \frac{x}{r} \sum_{i=1}^{N} \mathrm{coeffs[i]} \ r^i \]

where \(r\) is the magnitude of \(x\).

Parameters

coeffs

radial polynomial coefficients. May be an empty vector to represent the identity transformation; otherwise must have size > 1, coeffs[0] = 0, and coeffs[1] ≠ 0.

Returns

the radial distortion represented by coeffs. The Transform shall have an inverse, which may be approximate.

Exceptions

pex::exceptions::InvalidParameterError

Thrown if coeffs does not have the required format.

Exception Safety

Provides basic exception safety.

Definition at line 165 of file transformFactory.cc.

                                                                                            {
    if (!areRadialCoefficients(coeffs)) {
        std::ostringstream buffer;
        buffer << "Invalid coefficient vector: " << coeffs;
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, buffer.str());
    }

    if (coeffs.empty()) {
        return std::make_shared<TransformPoint2ToPoint2>(ast::UnitMap(2));
    } else {
        // distortion is a radial polynomial with center at focal plane center;
        // the polynomial has an iterative inverse
        std::vector<double> center = {0.0, 0.0};
        ast::PolyMap const distortion = makeOneDDistortion(coeffs);
        return std::make_shared<TransformPoint2ToPoint2>(*ast::makeRadialMapping(center, distortion));
    }
}

makeRadialTransform() [2/2]

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::makeRadialTransform	(	std::vector< double > const &	forwardCoeffs,
		std::vector< double > const &	inverseCoeffs
	)

A purely radial polynomial distortion.

Similar to makeRadialTransform(std::vector<double> const &), but allows the user to provide an inverse.

Parameters

forwardCoeffs	radial polynomial coefficients. May be an empty vector to represent the identity transformation; otherwise must have size > 1, coeffs[0] = 0, and coeffs[1] ≠ 0.
inverseCoeffs	coefficients for the inverse transform, as above. Does not need to have the same degree as forwardCoeffs, but either both must be empty or neither must be empty.

Returns

the radial distortion represented by coeffs. The Transform shall have an inverse, whose accuracy is determined by the relationship between forwardCoeffs and inverseCoeffs.

Exceptions

pex::exceptions::InvalidParameterError

Thrown if forwardCoeffs or inverseCoeffs does not have the required format.

Exception Safety

Provides basic exception safety.

Definition at line 183 of file transformFactory.cc.

                                                                                                     {
    if (forwardCoeffs.empty() != inverseCoeffs.empty()) {
        throw LSST_EXCEPT(
                pex::exceptions::InvalidParameterError,
                "makeRadialTransform must have either both empty or both non-empty coefficient vectors.");
    }
    if (forwardCoeffs.empty()) {
        // no forward or inverse coefficients, so no distortion
        return std::make_shared<TransformPoint2ToPoint2>(ast::UnitMap(2));
    }

    if (!areRadialCoefficients(forwardCoeffs)) {
        std::ostringstream buffer;
        buffer << "Invalid forward coefficient vector: " << forwardCoeffs;
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, buffer.str());
    }
    if (!areRadialCoefficients(inverseCoeffs)) {
        std::ostringstream buffer;
        buffer << "Invalid inverse coefficient vector: " << inverseCoeffs;
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, buffer.str());
    }
    // distortion is a 1-d radial polynomial centered at focal plane center;
    // the polynomial has coefficients specified for both the forward and inverse directions
    std::vector<double> center = {0.0, 0.0};
    ast::PolyMap const forward = makeOneDDistortion(forwardCoeffs);
    auto inverse = makeOneDDistortion(inverseCoeffs).inverted();
    auto distortion = ast::TranMap(forward, *inverse);
    return std::make_shared<TransformPoint2ToPoint2>(*ast::makeRadialMapping(center, distortion));
}

makeSimpleWcsMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::makeSimpleWcsMetadata	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		std::string const &	projection = "TAN"
	)

Make FITS metadata for a simple FITS WCS (one with no distortion).

This can also be used as a starting point for creating metadata for more sophisticated FITS WCS.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]
[in]	projection	The name of the FITS WCS projection, e.g. "TAN" or "STG"

Definition at line 172 of file wcsUtils.cc.

                                                                                            {
    auto pl = std::make_shared<daf::base::PropertyList>();
    pl->add("RADESYS", "ICRS");
    pl->add("EQUINOX", 2000);  // not needed, but may help some older code
    pl->add("CTYPE1", "RA---" + projection);
    pl->add("CTYPE2", "DEC--" + projection);
    pl->add("CRPIX1", crpix[0] + 1);
    pl->add("CRPIX2", crpix[1] + 1);
    pl->add("CRVAL1", crval[0].asDegrees());
    pl->add("CRVAL2", crval[1].asDegrees());
    pl->add("CUNIT1", "deg");
    pl->add("CUNIT2", "deg");
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            if (cdMatrix(i, j) != 0.0) {
                std::string name = "CD" + std::to_string(i + 1) + "_" + std::to_string(j + 1);
                pl->add(name, cdMatrix(i, j));
            }
        }
    }
    return pl;
}

makeSipMatrixMetadata()

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::makeSipMatrixMetadata	(	Eigen::MatrixXd const &	matrix,
		std::string const &	name
	)

Definition at line 150 of file wcsUtils.cc.

                                                                                      {
    if (matrix.rows() != matrix.cols() || matrix.rows() < 1) {
        throw LSST_EXCEPT(lsst::pex::exceptions::TypeError,
                          "Matrix must be square and at least 1 x 1; dimensions = " +
                                  std::to_string(matrix.rows()) + " x " + std::to_string(matrix.cols()));
    }
    int const order = matrix.rows() - 1;
    auto metadata = std::make_shared<daf::base::PropertyList>();
    std::string cardName = name + "_ORDER";
    metadata->set(cardName, order);
    auto const coeffName = name + "_";
    for (int i = 0; i <= order; ++i) {
        for (int j = 0; j <= order; ++j) {
            if (matrix(i, j) != 0.0) {
                metadata->set(getSipCoeffCardName(coeffName, i, j), matrix(i, j));
            }
        }
    }
    return metadata;
}

makeSkyWcs() [1/3]

std::shared_ptr< SkyWcs > lsst::afw::geom::makeSkyWcs	(	daf::base::PropertySet &	metadata,
		bool	strip = false
	)

Construct a SkyWcs from FITS keywords.

This function is preferred over calling the SkyWcs metadata constructor directly because it allows us to change SkyWcs to an abstract base class in the future, without affecting code that constructs a WCS from FITS metadata.

Parameters

[in]	metadata	FITS header metadata
[in]	strip	If true: strip items from metadata used to create the WCS, such as RADESYS, EQUINOX, CTYPE12, CRPIX12, CRVAL12, etc. Always keep keywords that might be wanted for other purpposes, including NAXIS12 and date-related keywords such as "DATE-OBS" and "TIMESYS" (but not "EQUINOX").

Exceptions

lsst::pex::exceptions::TypeError

if the metadata does not describe a celestial WCS.

Definition at line 506 of file SkyWcs.cc.

                                                                           {
    return std::make_shared<SkyWcs>(metadata, strip);
}

makeSkyWcs() [2/3]

std::shared_ptr< SkyWcs > lsst::afw::geom::makeSkyWcs	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		std::string const &	projection = "TAN"
	)

Construct a simple FITS SkyWcs with no distortion.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the parent image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]. May be computed by calling makeCdMatrix.
[in]	projection	The name of the FITS WCS projection, e.g. "TAN" or "STG"

Definition at line 510 of file SkyWcs.cc.

                                                                                               {
    auto metadata = makeSimpleWcsMetadata(crpix, crval, cdMatrix, projection);
    return std::make_shared<SkyWcs>(*metadata);
}

makeSkyWcs() [3/3]

std::shared_ptr< SkyWcs > lsst::afw::geom::makeSkyWcs	(	TransformPoint2ToPoint2 const &	pixelsToFieldAngle,
		lsst::geom::Angle const &	orientation,
		bool	flipX,
		lsst::geom::SpherePoint const &	boresight,
		std::string const &	projection = "TAN"
	)

Construct a FITS SkyWcs from camera geometry.

Parameters

[in]	pixelsToFieldAngle	Transformation from pixels to field angle (in radians).
[in]	orientation	Position angle of focal plane +Y, measured from N through E at crval. At 0 degrees, +Y is along N and +X is along W/E if flipX false/true. At 90 degrees, +Y is along E and +X is along N/S if flipX false/true.
[in]	flipX	Flip x axis? See orientation for details.
[in]	boresight	ICRS sky position at the boresight (field angle (0, 0)).
[in]	projection	The name of the FITS WCS projection, e.g. "TAN" or "STG".

Returns

a SkyWcs whose sky origin is the boresight and pixel origin is focal plane (0, 0).

Note

Unlike makeCdMatrix, orientation is with respect to the focal plane axes, not the CCD axes. This is because field angle is defined with respect to focal plane axes.

Definition at line 516 of file SkyWcs.cc.

                                                                                                      {
    auto frameDict = makeSkyWcsFrameDict(pixelsToFieldAngle, orientation, flipX, boresight, projection);
    return std::make_shared<SkyWcs>(frameDict);
}

makeTanSipMetadata() [1/2]

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::makeTanSipMetadata	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		Eigen::MatrixXd const &	sipA,
		Eigen::MatrixXd const &	sipB
	)

Make metadata for a TAN-SIP WCS without inverse matrices.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the parent image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]. May be computed by calling makeCdMatrix.
[in]	sipA	Forward distortion matrix for axis 1
[in]	sipB	Forward distortion matrix for axis 2

Definition at line 198 of file wcsUtils.cc.

                                                                                       {
    auto metadata = makeSimpleWcsMetadata(crpix, crval, cdMatrix, "TAN-SIP");
    metadata->combine(makeSipMatrixMetadata(sipA, "A"));
    metadata->combine(makeSipMatrixMetadata(sipB, "B"));
    return metadata;
}

makeTanSipMetadata() [2/2]

std::shared_ptr< daf::base::PropertyList > lsst::afw::geom::makeTanSipMetadata	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		Eigen::MatrixXd const &	sipA,
		Eigen::MatrixXd const &	sipB,
		Eigen::MatrixXd const &	sipAp,
		Eigen::MatrixXd const &	sipBp
	)

Make metadata for a TAN-SIP WCS.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the parent image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]. May be computed by calling makeCdMatrix.
[in]	sipA	Forward distortion matrix for axis 1
[in]	sipB	Forward distortion matrix for axis 2
[in]	sipAp	Reverse distortion matrix for axis 1
[in]	sipBp	Reverse distortion matrix for axis 2

Definition at line 209 of file wcsUtils.cc.

                                                                {
    auto metadata = makeTanSipMetadata(crpix, crval, cdMatrix, sipA, sipB);
    metadata->combine(makeSipMatrixMetadata(sipAp, "AP"));
    metadata->combine(makeSipMatrixMetadata(sipBp, "BP"));
    return metadata;
}

makeTanSipWcs() [1/2]

std::shared_ptr< SkyWcs > lsst::afw::geom::makeTanSipWcs	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		Eigen::MatrixXd const &	sipA,
		Eigen::MatrixXd const &	sipB
	)

Construct a TAN-SIP SkyWcs with forward SIP distortion terms and an iterative inverse.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the parent image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]. May be computed by calling makeCdMatrix.
[in]	sipA	Forward distortion matrix for axis 1
[in]	sipB	Forward distortion matrix for axis 2

Definition at line 523 of file SkyWcs.cc.

                                                                 {
    auto metadata = makeTanSipMetadata(crpix, crval, cdMatrix, sipA, sipB);
    return std::make_shared<SkyWcs>(*metadata);
}

makeTanSipWcs() [2/2]

std::shared_ptr< SkyWcs > lsst::afw::geom::makeTanSipWcs	(	lsst::geom::Point2D const &	crpix,
		lsst::geom::SpherePoint const &	crval,
		Eigen::Matrix2d const &	cdMatrix,
		Eigen::MatrixXd const &	sipA,
		Eigen::MatrixXd const &	sipB,
		Eigen::MatrixXd const &	sipAp,
		Eigen::MatrixXd const &	sipBp
	)

Construct a TAN WCS with forward and inverse SIP distortion terms.

Parameters

[in]	crpix	Center of projection on the CCD using the LSST convention: 0, 0 is the lower left pixel of the parent image
[in]	crval	Center of projection on the sky
[in]	cdMatrix	CD matrix, where element (i-1, j-1) corresponds to FITS keyword CDi_j and i, j have range [1, 2]. May be computed by calling makeCdMatrix.
[in]	sipA	Forward distortion matrix for axis 1
[in]	sipB	Forward distortion matrix for axis 2
[in]	sipAp	Reverse distortion matrix for axis 1
[in]	sipBp	Reverse distortion matrix for axis 2

Definition at line 530 of file SkyWcs.cc.

                                                                  {
    auto metadata = makeTanSipMetadata(crpix, crval, cdMatrix, sipA, sipB, sipAp, sipBp);
    return std::make_shared<SkyWcs>(*metadata);
}

makeTransform()

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::makeTransform

(

lsst::geom::AffineTransform const &

affine

)

Wrap an lsst::geom::AffineTransform as a Transform.

Parameters

affine

The lsst::geom::AffineTransform to wrap.

Returns

a Transform that that maps any lsst::geom::Point2D x to affine(x). It shall be invertible iff affine is invertible.

Exception Safety

Provides basic exception safety.

Definition at line 154 of file transformFactory.cc.

                                                                                            {
    auto const offset = lsst::geom::Point2D(affine.getTranslation());
    auto const jacobian = affine.getLinear().getMatrix();

    Point2Endpoint toEndpoint;
    auto const map = ast::MatrixMap(toNdArray(jacobian))
                             .then(ast::ShiftMap(toEndpoint.dataFromPoint(offset)))
                             .simplified();
    return std::make_shared<TransformPoint2ToPoint2>(*map);
}

makeWcsPairTransform()

std::shared_ptr< TransformPoint2ToPoint2 > lsst::afw::geom::makeWcsPairTransform	(	SkyWcs const &	src,
		SkyWcs const &	dst
	)

A Transform obtained by putting two SkyWcs objects "back to back".

Parameters

src	the WCS for the source pixels
dst	the WCS for the destination pixels

Returns

a Transform whose forward transformation converts from src pixels to dst pixels, and whose inverse transformation converts in the opposite direction.

Exception Safety

Provides basic exception safety.

Definition at line 151 of file SkyWcs.cc.

                                                                                                  {
    auto const dstInverse = dst.getTransform()->inverted();
    return src.getTransform()->then(*dstInverse);
}

operator<<() [1/5]

template<class FromEndpoint , class ToEndpoint >

std::ostream & lsst::afw::geom::operator<<	(	std::ostream &	os,
		Transform< FromEndpoint, ToEndpoint > const &	transform
	)

Print a Transform to an ostream.

The format is "Transform<_fromEndpoint_, _toEndpoint_>" where fromEndpoint and toEndpoint are the appropriate endpoint printed to the ostream; for example "Transform<GenericEndpoint(4), Point2Endpoint()>"

Definition at line 189 of file Transform.cc.

                                                                                             {
    os << "Transform<" << transform.getFromEndpoint() << ", " << transform.getToEndpoint() << ">";
    return os;
};

operator<<() [2/5]

std::ostream & lsst::afw::geom::operator<<	(	std::ostream &	os,
		GenericEndpoint const &	endpoint
	)

Print "GenericEndpoint(_n_)" to the ostream where _n_ is the number of axes, e.g. "GenericAxes(4)".

Definition at line 240 of file Endpoint.cc.

                                                                        {
    os << "GenericEndpoint(" << endpoint.getNAxes() << ")";
    return os;
}

operator<<() [3/5]

std::ostream & lsst::afw::geom::operator<<	(	std::ostream &	os,
		Point2Endpoint const &	endpoint
	)

Print "Point2Endpoint()" to the ostream.

Definition at line 245 of file Endpoint.cc.

                                                                       {
    os << "Point2Endpoint()";
    return os;
}

operator<<() [4/5]

std::ostream & lsst::afw::geom::operator<<	(	std::ostream &	os,
		SpherePointEndpoint const &	endpoint
	)

Print "SpherePointEndpoint()" to the ostream.

Definition at line 250 of file Endpoint.cc.

                                                                            {
    os << "SpherePointEndpoint()";
    return os;
}

operator<<() [5/5]

std::ostream & lsst::afw::geom::operator<<	(	std::ostream &	os,
		SkyWcs const &	wcs
	)

Print a SkyWcs to an ostream (delegates to SkyWcs.toString()).

Definition at line 549 of file SkyWcs.cc.

                                                          {
    os << wcs.toString();
    return os;
};

operator<<< GenericEndpoint, GenericEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< GenericEndpoint, GenericEndpoint >	(	std::ostream &	os,
		Transform< GenericEndpoint, GenericEndpoint > const &	transform
	)

operator<<< GenericEndpoint, Point2Endpoint >()

template std::ostream& lsst::afw::geom::operator<<< GenericEndpoint, Point2Endpoint >	(	std::ostream &	os,
		Transform< GenericEndpoint, Point2Endpoint > const &	transform
	)

operator<<< GenericEndpoint, SpherePointEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< GenericEndpoint, SpherePointEndpoint >	(	std::ostream &	os,
		Transform< GenericEndpoint, SpherePointEndpoint > const &	transform
	)

operator<<< Point2Endpoint, GenericEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< Point2Endpoint, GenericEndpoint >	(	std::ostream &	os,
		Transform< Point2Endpoint, GenericEndpoint > const &	transform
	)

operator<<< Point2Endpoint, Point2Endpoint >()

template std::ostream& lsst::afw::geom::operator<<< Point2Endpoint, Point2Endpoint >	(	std::ostream &	os,
		Transform< Point2Endpoint, Point2Endpoint > const &	transform
	)

operator<<< Point2Endpoint, SpherePointEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< Point2Endpoint, SpherePointEndpoint >	(	std::ostream &	os,
		Transform< Point2Endpoint, SpherePointEndpoint > const &	transform
	)

operator<<< SpherePointEndpoint, GenericEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< SpherePointEndpoint, GenericEndpoint >	(	std::ostream &	os,
		Transform< SpherePointEndpoint, GenericEndpoint > const &	transform
	)

operator<<< SpherePointEndpoint, Point2Endpoint >()

template std::ostream& lsst::afw::geom::operator<<< SpherePointEndpoint, Point2Endpoint >	(	std::ostream &	os,
		Transform< SpherePointEndpoint, Point2Endpoint > const &	transform
	)

operator<<< SpherePointEndpoint, SpherePointEndpoint >()

template std::ostream& lsst::afw::geom::operator<<< SpherePointEndpoint, SpherePointEndpoint >	(	std::ostream &	os,
		Transform< SpherePointEndpoint, SpherePointEndpoint > const &	transform
	)

PYBIND11_MODULE()

lsst::afw::geom::PYBIND11_MODULE	(	spanSet	,
		mod
	)

Definition at line 195 of file spanSet.cc.

                              {
    using MaskPixel = image::MaskPixel;

    py::module::import("lsst.geom");
    py::module::import("lsst.afw.geom.span");

    py::enum_<Stencil>(mod, "Stencil")
            .value("CIRCLE", Stencil::CIRCLE)
            .value("BOX", Stencil::BOX)
            .value("MANHATTAN", Stencil::MANHATTAN);

    PySpanSet cls(mod, "SpanSet");

    /* SpanSet Constructors */
    cls.def(py::init<>());
    cls.def(py::init<lsst::geom::Box2I>(), "box"_a);
    cls.def(py::init<std::vector<Span>, bool>(), "spans"_a, "normalize"_a = true);

    table::io::python::addPersistableMethods<SpanSet>(cls);

    /* SpanSet Methods */
    cls.def("getArea", &SpanSet::getArea);
    cls.def("getBBox", &SpanSet::getBBox);
    cls.def("isContiguous", &SpanSet::isContiguous);
    cls.def("shiftedBy", (std::shared_ptr<SpanSet>(SpanSet::*)(int, int) const) & SpanSet::shiftedBy);
    cls.def("shiftedBy",
            (std::shared_ptr<SpanSet>(SpanSet::*)(lsst::geom::Extent2I const &) const) & SpanSet::shiftedBy);
    cls.def("clippedTo", &SpanSet::clippedTo);
    cls.def("transformedBy",
            (std::shared_ptr<SpanSet>(SpanSet::*)(lsst::geom::LinearTransform const &) const) &
                    SpanSet::transformedBy);
    cls.def("transformedBy",
            (std::shared_ptr<SpanSet>(SpanSet::*)(lsst::geom::AffineTransform const &) const) &
                    SpanSet::transformedBy);
    cls.def("transformedBy", (std::shared_ptr<SpanSet>(SpanSet::*)(TransformPoint2ToPoint2 const &) const) &
                                     SpanSet::transformedBy);
    cls.def("overlaps", &SpanSet::overlaps);
    cls.def("contains", (bool (SpanSet::*)(SpanSet const &) const) & SpanSet::contains);
    cls.def("contains", (bool (SpanSet::*)(lsst::geom::Point2I const &) const) & SpanSet::contains);
    cls.def("computeCentroid", &SpanSet::computeCentroid);
    cls.def("computeShape", &SpanSet::computeShape);
    cls.def("dilated", (std::shared_ptr<SpanSet>(SpanSet::*)(int, Stencil) const) & SpanSet::dilated,
            "radius"_a, "stencil"_a = Stencil::CIRCLE);
    cls.def("dilated", (std::shared_ptr<SpanSet>(SpanSet::*)(SpanSet const &) const) & SpanSet::dilated);
    cls.def("eroded", (std::shared_ptr<SpanSet>(SpanSet::*)(int, Stencil) const) & SpanSet::eroded,
            "radius"_a, "stencil"_a = Stencil::CIRCLE);
    cls.def("eroded", (std::shared_ptr<SpanSet>(SpanSet::*)(SpanSet const &) const) & SpanSet::eroded);
    cls.def("intersect", (std::shared_ptr<SpanSet>(SpanSet::*)(SpanSet const &) const) & SpanSet::intersect);
    cls.def("intersectNot",
            (std::shared_ptr<SpanSet>(SpanSet::*)(SpanSet const &) const) & SpanSet::intersectNot);
    cls.def("union", (std::shared_ptr<SpanSet>(SpanSet::*)(SpanSet const &) const) & SpanSet::union_);
    cls.def_static("fromShape",
                   (std::shared_ptr<SpanSet>(*)(int, Stencil, lsst::geom::Point2I)) & SpanSet::fromShape,
                   "radius"_a, "stencil"_a = Stencil::CIRCLE, "offset"_a = lsst::geom::Point2I());
    cls.def_static("fromShape",
                   [](int r, Stencil s, std::pair<int, int> point) {
                       return SpanSet::fromShape(r, s, lsst::geom::Point2I(point.first, point.second));
                   },
                   "radius"_a, "stencil"_a = Stencil::CIRCLE, "offset"_a = std::pair<int, int>(0, 0));
    cls.def_static("fromShape",
                   (std::shared_ptr<SpanSet>(*)(geom::ellipses::Ellipse const &)) & SpanSet::fromShape);
    cls.def("split", &SpanSet::split);
    cls.def("findEdgePixels", &SpanSet::findEdgePixels);
    cls.def("indices", [](SpanSet const &self) -> std::pair<std::vector<int>, std::vector<int>> {
        std::vector<int> yind;
        std::vector<int> xind;
        yind.reserve(self.getArea());
        xind.reserve(self.getArea());
        for (auto const &span : self) {
            auto y = span.getY();
            for (int x = span.getX0(); x <= span.getX1(); ++x) {
                yind.push_back(y);
                xind.push_back(x);
            }
        }
        return std::make_pair(yind, xind);
    });

    /* SpanSet Operators */
    cls.def("__eq__", [](SpanSet const &self, SpanSet const &other) -> bool { return self == other; },
            py::is_operator());
    cls.def("__ne__", [](SpanSet const &self, SpanSet const &other) -> bool { return self != other; },
            py::is_operator());
    cls.def("__iter__", [](SpanSet &self) { return py::make_iterator(self.begin(), self.end()); },
            py::keep_alive<0, 1>());
    cls.def("__len__", [](SpanSet const &self) -> decltype(self.size()) { return self.size(); });
    cls.def("__contains__", [](SpanSet &self, SpanSet const &other) -> bool { return self.contains(other); });
    cls.def("__contains__",
            [](SpanSet &self, lsst::geom::Point2I &other) -> bool { return self.contains(other); });
    cls.def("__repr__", [](SpanSet const &self) -> std::string {
        std::ostringstream os;
        image::Mask<MaskPixel> tempMask(self.getBBox());
        self.setMask(tempMask, static_cast<MaskPixel>(1));
        auto array = tempMask.getArray();
        auto dims = array.getShape();
        for (std::size_t i = 0; i < dims[0]; ++i) {
            os << "[";
            for (std::size_t j = 0; j < dims[1]; ++j) {
                os << array[i][j];
                if (j != dims[1] - 1) {
                    os << ", ";
                }
            }
            os << "]" << std::endl;
        }
        return os.str();
    });
    cls.def("__str__", [](SpanSet const &self) -> std::string {
        std::ostringstream os;
        for (auto const &span : self) {
            os << span.getY() << ": " << span.getMinX() << ".." << span.getMaxX() << std::endl;
        }
        return os.str();
    });
    // Instantiate all the templates

    declareMaskMethods<MaskPixel>(cls);

    declareImageTypes<std::uint16_t>(cls);
    declareImageTypes<std::uint64_t>(cls);
    declareImageTypes<int>(cls);
    declareImageTypes<float>(cls);
    declareImageTypes<double>(cls);

    // Extra instantiation for flatten unflatten methods
    declareFlattenMethod<long>(cls);
    declareUnflattenMethod<long>(cls);

    declarefromMask<MaskPixel>(cls);
}

SpanSet::clearMask< image::MaskPixel >()

template void lsst::afw::geom::SpanSet::clearMask< image::MaskPixel >	(	image::Mask< image::MaskPixel > &	target,
		image::MaskPixel	bitmask
	)		const

SpanSet::intersect< image::MaskPixel >()

template std::shared_ptr<SpanSet> lsst::afw::geom::SpanSet::intersect< image::MaskPixel >	(	image::Mask< image::MaskPixel > const &	other,
		image::MaskPixel	bitmask
	)		const

SpanSet::intersectNot< image::MaskPixel >()

template std::shared_ptr<SpanSet> lsst::afw::geom::SpanSet::intersectNot< image::MaskPixel >	(	image::Mask< image::MaskPixel > const &	other,
		image::MaskPixel	bitmask
	)		const

SpanSet::setImage< std::uint16_t >()

template void lsst::afw::geom::SpanSet::setImage< std::uint16_t >	(	image::Image< std::uint16_t > &	image,
		std::uint16_t	val,
		lsst::geom::Box2I const &	region = lsst::geom::Box2I(),
		bool	doClip = false
	)		const

SpanSet::setImage< std::uint64_t >()

template void lsst::afw::geom::SpanSet::setImage< std::uint64_t >	(	image::Image< std::uint64_t > &	image,
		std::uint64_t	val,
		lsst::geom::Box2I const &	region = lsst::geom::Box2I(),
		bool	doClip = false
	)		const

SpanSet::setMask< image::MaskPixel >()

template void lsst::afw::geom::SpanSet::setMask< image::MaskPixel >	(	image::Mask< image::MaskPixel > &	target,
		image::MaskPixel	bitmask
	)		const

SpanSet::union_< image::MaskPixel >()

template std::shared_ptr<SpanSet> lsst::afw::geom::SpanSet::union_< image::MaskPixel >	(	image::Mask< image::MaskPixel > const &	other,
		image::MaskPixel	bitmask
	)		const

Variable Documentation

AffineTransform

lsst.afw.geom.AffineTransform

Initial value:

=  deprecate_pybind11(AffineTransform,
                                     reason="Replaced by lsst.geom.AffineTransform (will be removed before the release of v20.0)")

Definition at line 43 of file __init__.py.

Angle

lsst.afw.geom.Angle

Initial value:

=  deprecate_pybind11(Angle,
                           reason="Replaced by lsst.geom.Angle (will be removed before the release of v20.0)")

Definition at line 45 of file __init__.py.

AngleUnit

lsst.afw.geom.AngleUnit

Initial value:

=  deprecate_pybind11(AngleUnit,
                               reason="Replaced by lsst.geom.AngleUnit (will be removed before the release of v20.0)")

Definition at line 47 of file __init__.py.

arcsecToRad

lsst.afw.geom.arcsecToRad

Initial value:

=  deprecate_pybind11(arcsecToRad,
                                 reason="Replaced by lsst.geom.arcsecToRad (will be removed before the release of v20.0)")

Definition at line 110 of file __init__.py.

averageSpherePoint

lsst.afw.geom.averageSpherePoint

Initial value:

=  deprecate_pybind11(averageSpherePoint,
                                        reason="Replaced by lsst.geom.averageSpherePoint (will be removed before the release of v20.0)")

Definition at line 112 of file __init__.py.

Box2D

lsst.afw.geom.Box2D

Initial value:

=  deprecate_pybind11(Box2D,
                           reason="Replaced by lsst.geom.Box2D (will be removed before the release of v20.0)")

Definition at line 49 of file __init__.py.

Box2I

lsst.afw.geom.Box2I

Initial value:

=  deprecate_pybind11(Box2I,
                           reason="Replaced by lsst.geom.Box2I (will be removed before the release of v20.0)")

Definition at line 51 of file __init__.py.

BoxD

lsst.afw.geom.BoxD

Initial value:

=  deprecate_pybind11(BoxD,
                          reason="Replaced by lsst.geom.BoxD (will be removed before the release of v20.0)")

Definition at line 53 of file __init__.py.

BoxI

lsst.afw.geom.BoxI

Initial value:

=  deprecate_pybind11(BoxI,
                          reason="Replaced by lsst.geom.BoxI (will be removed before the release of v20.0)")

Definition at line 55 of file __init__.py.

CoordinateExpr

lsst.afw.geom.CoordinateExpr

Initial value:

=  deprecate_pybind11(CoordinateExpr,
                                    reason="Replaced by lsst.geom.CoordinateExpr (will be removed before the release of v20.0)")

Definition at line 58 of file __init__.py.

CoordinateExpr2

lsst.afw.geom.CoordinateExpr2

Initial value:

=  deprecate_pybind11(CoordinateExpr2,
                                     reason="Replaced by lsst.geom.CoordinateExpr2 (will be removed before the release of v20.0)")

Definition at line 60 of file __init__.py.

CoordinateExpr3

lsst.afw.geom.CoordinateExpr3

Initial value:

=  deprecate_pybind11(CoordinateExpr3,
                                     reason="Replaced by lsst.geom.CoordinateExpr3 (will be removed before the release of v20.0)")

Definition at line 62 of file __init__.py.

degToRad

lsst.afw.geom.degToRad

Initial value:

=  deprecate_pybind11(degToRad,
                              reason="Replaced by lsst.geom.degToRad (will be removed before the release of v20.0)")

Definition at line 114 of file __init__.py.

Extent

lsst.afw.geom.Extent

Initial value:

=  deprecate_pybind11(Extent,
                            reason="Replaced by lsst.geom.Extent (will be removed before the release of v20.0)")

Definition at line 64 of file __init__.py.

Extent2D

lsst.afw.geom.Extent2D

Initial value:

=  deprecate_pybind11(Extent2D,
                              reason="Replaced by lsst.geom.Extent2D (will be removed before the release of v20.0)")

Definition at line 66 of file __init__.py.

Extent2I

lsst.afw.geom.Extent2I

Initial value:

=  deprecate_pybind11(Extent2I,
                              reason="Replaced by lsst.geom.Extent2I (will be removed before the release of v20.0)")

Definition at line 68 of file __init__.py.

Extent3D

lsst.afw.geom.Extent3D

Initial value:

=  deprecate_pybind11(Extent3D,
                              reason="Replaced by lsst.geom.Extent3D (will be removed before the release of v20.0)")

Definition at line 70 of file __init__.py.

Extent3I

lsst.afw.geom.Extent3I

Initial value:

=  deprecate_pybind11(Extent3I,
                              reason="Replaced by lsst.geom.Extent3I (will be removed before the release of v20.0)")

Definition at line 72 of file __init__.py.

ExtentBase2D

lsst.afw.geom.ExtentBase2D

Initial value:

=  deprecate_pybind11(ExtentBase2D,
                                  reason="Replaced by lsst.geom.ExtentBase2D (will be removed before the release of v20.0)")

Definition at line 74 of file __init__.py.

ExtentBase2I

lsst.afw.geom.ExtentBase2I

Initial value:

=  deprecate_pybind11(ExtentBase2I,
                                  reason="Replaced by lsst.geom.ExtentBase2I (will be removed before the release of v20.0)")

Definition at line 76 of file __init__.py.

ExtentBase3D

lsst.afw.geom.ExtentBase3D

Initial value:

=  deprecate_pybind11(ExtentBase3D,
                                  reason="Replaced by lsst.geom.ExtentBase3D (will be removed before the release of v20.0)")

Definition at line 78 of file __init__.py.

ExtentBase3I

lsst.afw.geom.ExtentBase3I = deprecate_pybind11(ExtentBase3I, reason="Replaced by lsst.geom.ExtentBase3I (will be removed before the release of v20.0)")

Definition at line 80 of file __init__.py.

ExtentD

lsst.afw.geom.ExtentD

Initial value:

=  deprecate_pybind11(ExtentD,
                             reason="Replaced by lsst.geom.ExtentD (will be removed before the release of v20.0)")

Definition at line 81 of file __init__.py.

ExtentI

lsst.afw.geom.ExtentI

Initial value:

=  deprecate_pybind11(ExtentI,
                             reason="Replaced by lsst.geom.ExtentI (will be removed before the release of v20.0)")

Definition at line 83 of file __init__.py.

isAngle

lsst.afw.geom.isAngle

Initial value:

=  deprecate_pybind11(isAngle,
                             reason="Replaced by lsst.geom.isAngle (will be removed before the release of v20.0)")

Definition at line 116 of file __init__.py.

LinearTransform

lsst.afw.geom.LinearTransform

Initial value:

=  deprecate_pybind11(LinearTransform,
                                     reason="Replaced by lsst.geom.LinearTransform (will be removed before the release of v20.0)")

Definition at line 85 of file __init__.py.

makeAffineTransformFromTriple

lsst.afw.geom.makeAffineTransformFromTriple

Initial value:

=  deprecate_pybind11(makeAffineTransformFromTriple,
                                                   reason="Replaced by lsst.geom.makeAffineTransformFromTriple (will be removed before the release of v20.0)")

Definition at line 118 of file __init__.py.

masToRad

lsst.afw.geom.masToRad

Initial value:

=  deprecate_pybind11(masToRad,
                              reason="Replaced by lsst.geom.masToRad (will be removed before the release of v20.0)")

Definition at line 120 of file __init__.py.

Point

lsst.afw.geom.Point

Initial value:

=  deprecate_pybind11(Point,
                           reason="Replaced by lsst.geom.Point (will be removed before the release of v20.0)")

Definition at line 87 of file __init__.py.

Point2D

lsst.afw.geom.Point2D

Initial value:

=  deprecate_pybind11(Point2D,
                             reason="Replaced by lsst.geom.Point2D (will be removed before the release of v20.0)")

Definition at line 89 of file __init__.py.

Point2I

lsst.afw.geom.Point2I

Initial value:

=  deprecate_pybind11(Point2I,
                             reason="Replaced by lsst.geom.Point2I (will be removed before the release of v20.0)")

Definition at line 91 of file __init__.py.

Point3D

lsst.afw.geom.Point3D

Initial value:

=  deprecate_pybind11(Point3D,
                             reason="Replaced by lsst.geom.Point3D (will be removed before the release of v20.0)")

Definition at line 93 of file __init__.py.

Point3I

lsst.afw.geom.Point3I

Initial value:

=  deprecate_pybind11(Point3I,
                             reason="Replaced by lsst.geom.Point3I (will be removed before the release of v20.0)")

Definition at line 95 of file __init__.py.

PointBase2D

lsst.afw.geom.PointBase2D

Initial value:

=  deprecate_pybind11(PointBase2D,
                                 reason="Replaced by lsst.geom.PointBase2D (will be removed before the release of v20.0)")

Definition at line 97 of file __init__.py.

PointBase2I

lsst.afw.geom.PointBase2I

Initial value:

=  deprecate_pybind11(PointBase2I,
                                 reason="Replaced by lsst.geom.PointBase2I (will be removed before the release of v20.0)")

Definition at line 99 of file __init__.py.

PointBase3D

lsst.afw.geom.PointBase3D = deprecate_pybind11(PointBase3D, reason="Replaced by lsst.geom.PointBase3D (will be removed before the release of v20.0)")

Definition at line 101 of file __init__.py.

PointBase3I

lsst.afw.geom.PointBase3I

Initial value:

=  deprecate_pybind11(PointBase3I,
                                 reason="Replaced by lsst.geom.PointBase3I (will be removed before the release of v20.0)")

Definition at line 102 of file __init__.py.

PointD

lsst.afw.geom.PointD

Initial value:

=  deprecate_pybind11(PointD,
                            reason="Replaced by lsst.geom.PointD (will be removed before the release of v20.0)")

Definition at line 104 of file __init__.py.

PointI

lsst.afw.geom.PointI

Initial value:

=  deprecate_pybind11(PointI,
                            reason="Replaced by lsst.geom.PointI (will be removed before the release of v20.0)")

Definition at line 106 of file __init__.py.

radToArcsec

lsst.afw.geom.radToArcsec

Initial value:

=  deprecate_pybind11(radToArcsec,
                                 reason="Replaced by lsst.geom.radToArcsec (will be removed before the release of v20.0)")

Definition at line 122 of file __init__.py.

radToDeg

lsst.afw.geom.radToDeg

Initial value:

=  deprecate_pybind11(radToDeg,
                              reason="Replaced by lsst.geom.radToDeg (will be removed before the release of v20.0)")

Definition at line 124 of file __init__.py.

radToMas

lsst.afw.geom.radToMas

Initial value:

=  deprecate_pybind11(radToMas,
                              reason="Replaced by lsst.geom.radToMas (will be removed before the release of v20.0)")

Definition at line 126 of file __init__.py.

SpherePoint

lsst.afw.geom.SpherePoint

Initial value:

=  deprecate_pybind11(SpherePoint,
                                 reason="Replaced by lsst.geom.SpherePoint (will be removed before the release of v20.0)")

Definition at line 108 of file __init__.py.