lsst::afw::geom::polygon::Polygon Class Reference

Cartesian polygons. More...

#include <Polygon.h>

Inheritance diagram for lsst::afw::geom::polygon::Polygon:

Classes
struct	Impl

Public Types
using	Box = lsst::geom::Box2D
using	Point = lsst::geom::Point2D

Public Member Functions
	Polygon (Box const &box)
	Construct a rectangular Polygon whose vertices are the corners of a box.
	Polygon (Polygon const &)
	Polygon (Polygon &&)
Polygon &	operator= (Polygon const &)
Polygon &	operator= (Polygon &&)
	~Polygon () override
	Polygon (Box const &box, TransformPoint2ToPoint2 const &transform)
	Construct a 4-sided Polygon from a transformed box.
	Polygon (Box const &box, lsst::geom::AffineTransform const &transform)
	Construct a 4-sided Polygon from a transformed box.
	Polygon (std::vector< Point > const &vertices)
	Construct a Polygon from a list of vertices.
void	swap (Polygon &other) noexcept
	Swap two polygons.
size_t	getNumEdges () const
	Return number of edges.
Box	getBBox () const
	Return bounding box.
Point	calculateCenter () const
double	calculateArea () const
double	calculatePerimeter () const
std::vector< Point >	getVertices () const
	Get vector of vertices.
std::vector< Point >::const_iterator	begin () const
	Iterator for vertices.
std::vector< Point >::const_iterator	end () const
std::vector< std::pair< Point, Point > >	getEdges () const
	Get vector of edges.
bool	operator== (Polygon const &other) const
bool	operator!= (Polygon const &other) const
std::size_t	hash_value () const noexcept override
	Return a hash of this object.
bool	contains (Point const &point) const
	Returns whether the polygon contains the point.
std::vector< bool >	contains (std::vector< Point > const &points) const
	Returns whether the polygon contains the vector of points.
std::vector< bool >	contains (std::vector< lsst::geom::Point2I > const &points) const
template<typename Xtype , typename Ytype >
bool	contains (Xtype x, Ytype y) const
	Returns whether the polygon contains the x, y pair.
bool	overlaps (Polygon const &other) const
	Returns whether the polygons overlap each other.
bool	overlaps (Box const &box) const
std::shared_ptr< Polygon >	intersectionSingle (Polygon const &other) const
	Returns the intersection of two polygons.
std::shared_ptr< Polygon >	intersectionSingle (Box const &box) const
std::vector< std::shared_ptr< Polygon > >	intersection (Polygon const &other) const
	Returns the intersection of two polygons.
std::vector< std::shared_ptr< Polygon > >	intersection (Box const &box) const
std::shared_ptr< Polygon >	unionSingle (Polygon const &other) const
	Returns the union of two polygons.
std::shared_ptr< Polygon >	unionSingle (Box const &box) const
std::vector< std::shared_ptr< Polygon > >	union_ (Polygon const &other) const
	Returns the union of two polygons.
std::vector< std::shared_ptr< Polygon > >	union_ (Box const &box) const
std::vector< std::shared_ptr< Polygon > >	symDifference (Polygon const &other) const
	Return the symmetric difference of two polygons.
std::vector< std::shared_ptr< Polygon > >	symDifference (Box const &box) const
std::shared_ptr< Polygon >	simplify (double const distance) const
	Return a simplified polygon.
std::vector< std::shared_ptr< Polygon > >	operator& (Polygon const &rhs) const
	Operators for syntactic sugar.
std::vector< std::shared_ptr< Polygon > >	operator& (Box const &rhs) const
std::vector< std::shared_ptr< Polygon > >	operator| (Polygon const &rhs) const
std::vector< std::shared_ptr< Polygon > >	operator| (Box const &rhs) const
std::vector< std::shared_ptr< Polygon > >	operator^ (Polygon const &rhs) const
std::vector< std::shared_ptr< Polygon > >	operator^ (Box const &rhs) const
std::shared_ptr< Polygon >	convexHull () const
	Produce a polygon from the convex hull.
std::shared_ptr< Polygon >	transform (TransformPoint2ToPoint2 const &transform) const
	Transform the polygon.
std::shared_ptr< Polygon >	transform (lsst::geom::AffineTransform const &transform) const
std::shared_ptr< Polygon >	subSample (size_t num) const
	Sub-sample each edge.
std::shared_ptr< Polygon >	subSample (double maxLength) const
std::shared_ptr< afw::image::Image< float > >	createImage (lsst::geom::Box2I const &bbox) const
	Create image of polygon.
std::shared_ptr< afw::image::Image< float > >	createImage (lsst::geom::Extent2I const &extent) const
bool	isPersistable () const noexcept override
	Whether Polygon is persistable which is always true.
std::shared_ptr< typehandling::Storable >	cloneStorable () const override
	Create a new Polygon that is a copy of this one.
std::string	toString () const override
	Create a string representation of this object.
bool	equals (typehandling::Storable const &other) const noexcept override
	Compare this object to another Storable.
	__repr__ (self)
	__reduce__ (self)
	__iter__ (self)
	__getitem__ (self, i)
	__len__ (self)
	__contains__ (self, point)
	display (self, xy0=None, frame=1, ctype=None)
	plot (self, axes=None, **kwargs)
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file.
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory.
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object.

Static Public Member Functions
static std::shared_ptr< Polygon >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.
static std::shared_ptr< Polygon >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.
static std::shared_ptr< Polygon >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.
static std::shared_ptr< Polygon >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

Protected Types
using	OutputArchiveHandle = io::OutputArchiveHandle

Protected Member Functions
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory.
void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs.
virtual std::string	getPythonModule () const
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Static Protected Member Functions
template<class T >
static bool	singleClassEquals (T const &lhs, Storable const &rhs)
	Test if a Storable is of a particular class and equal to another object.

Related Symbols
(Note that these are not member symbols.)
std::ostream &	operator<< (std::ostream &os, Storable const &storable)
	Output operator for Storable.

Detailed Description

Cartesian polygons.

Polygons are defined by a set of vertices

Definition at line 59 of file Polygon.h.

Member Typedef Documentation

Box

using lsst::afw::geom::polygon::Polygon::Box = lsst::geom::Box2D

Definition at line 61 of file Polygon.h.

OutputArchiveHandle

using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

Point

using lsst::afw::geom::polygon::Polygon::Point = lsst::geom::Point2D

Definition at line 62 of file Polygon.h.

Constructor & Destructor Documentation

Polygon() [1/6]

lsst::afw::geom::polygon::Polygon::Polygon ( Polygon::Box const & box )

explicit

Construct a rectangular Polygon whose vertices are the corners of a box.

Definition at line 288 of file Polygon.cc.

: _impl(new Polygon::Impl(box)) {}

Polygon() [2/6]

lsst::afw::geom::polygon::Polygon::Polygon ( Polygon const & )

default

Polygon() [3/6]

lsst::afw::geom::polygon::Polygon::Polygon ( Polygon && )

default

~Polygon()

lsst::afw::geom::polygon::Polygon::~Polygon ( )

overridedefault

Polygon() [4/6]

lsst::afw::geom::polygon::Polygon::Polygon	(	Polygon::Box const &	box,
		TransformPoint2ToPoint2 const &	transform )

Construct a 4-sided Polygon from a transformed box.

The resulting polygon has 4 vertices: transform.applyForward(bbox.getCorners())

Parameters

[in]	box	Initial box
[in]	transform	Coordinate transform

Definition at line 292 of file Polygon.cc.

        : _impl(new Polygon::Impl()) {
    auto corners = transform.applyForward(boxToCorners(box));
    boost::geometry::assign(_impl->poly, corners);
    _impl->check();
}

Polygon() [5/6]

lsst::afw::geom::polygon::Polygon::Polygon	(	Polygon::Box const &	box,
		lsst::geom::AffineTransform const &	transform )

Construct a 4-sided Polygon from a transformed box.

The resulting polygon has 4 vertices: the corners of the box transformed by transform

Parameters

[in]	box	Initial box
[in]	transform	Coordinate transform

Definition at line 299 of file Polygon.cc.

        : _impl(new Polygon::Impl()) {
    std::vector<LsstPoint> corners = boxToCorners(box);
    for (auto & corner : corners) {
        corner = transform(corner);
    }
    boost::geometry::assign(_impl->poly, corners);
    _impl->check();
}

Polygon() [6/6]

lsst::afw::geom::polygon::Polygon::Polygon ( std::vector< Point > const & vertices )

explicit

Construct a Polygon from a list of vertices.

Definition at line 290 of file Polygon.cc.

: _impl(new Polygon::Impl(vertices)) {}

Member Function Documentation

__contains__()

lsst.afw.geom.polygon.Polygon.__contains__	(		self,
			point )

point in polygon?

Definition at line 47 of file polygon.py.

    def __contains__(self, point):
        """point in polygon?"""
        return self.contains(point)
 

__getitem__()

lsst.afw.geom.polygon.Polygon.__getitem__	(		self,
			i )

Definition at line 41 of file polygon.py.

    def __getitem__(self, i):
        return [pt for pt in self][i]
 

__iter__()

lsst.afw.geom.polygon.Polygon.__iter__

(

self

)

Iterator over vertices

Definition at line 36 of file polygon.py.

    def __iter__(self):
        """Iterator over vertices"""
        vertices = self.getVertices()
        return iter(vertices)
 

__len__()

lsst.afw.geom.polygon.Polygon.__len__

(

self

)

Definition at line 44 of file polygon.py.

    def __len__(self):
        return self.getNumEdges()
 

__reduce__()

lsst.afw.geom.polygon.Polygon.__reduce__

(

self

)

Definition at line 33 of file polygon.py.

    def __reduce__(self):
        return self.__class__, (self.getVertices(),)
 

__repr__()

lsst.afw.geom.polygon.Polygon.__repr__

(

self

)

Definition at line 30 of file polygon.py.

    def __repr__(self):
        return f"{self.__class__.__name__}({[p for p in self.getVertices()]})"
 

begin()

std::vector< LsstPoint >::const_iterator lsst::afw::geom::polygon::Polygon::begin

(

)

const

Iterator for vertices.

Iterates only over the "open" polygon vertices (i.e., same number as returned by "getNumEdges").

Definition at line 339 of file Polygon.cc.

{ return _impl->poly.outer().begin(); }

calculateArea()

double lsst::afw::geom::polygon::Polygon::calculateArea

(

)

const

Definition at line 322 of file Polygon.cc.

{ return boost::geometry::area(_impl->poly); }

calculateCenter()

LsstPoint lsst::afw::geom::polygon::Polygon::calculateCenter

(

)

const

Definition at line 318 of file Polygon.cc.

                                         {
    return boost::geometry::return_centroid<LsstPoint>(_impl->poly);
}

calculatePerimeter()

double lsst::afw::geom::polygon::Polygon::calculatePerimeter

(

)

const

Definition at line 324 of file Polygon.cc.

{ return boost::geometry::perimeter(_impl->poly); }

cloneStorable()

std::shared_ptr< typehandling::Storable > lsst::afw::geom::polygon::Polygon::cloneStorable ( ) const

overridevirtual

Create a new Polygon that is a copy of this one.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 609 of file Polygon.cc.

                                                                 {
    return std::make_unique<Polygon>(*this);
}

contains() [1/4]

bool lsst::afw::geom::polygon::Polygon::contains

(

Point const &

point

)

const

Returns whether the polygon contains the point.

Definition at line 356 of file Polygon.cc.

{ return boost::geometry::within(point, _impl->poly); }

contains() [2/4]

std::vector< bool > lsst::afw::geom::polygon::Polygon::contains

(

std::vector< lsst::geom::Point2I > const &

points

)

const

Definition at line 366 of file Polygon.cc.

                                                                                {
    std::vector<bool> results;
    for (lsst::geom::PointI const & p : points) {
        results.push_back(contains(Point(p)));
    }
    return results;
}

contains() [3/4]

std::vector< bool > lsst::afw::geom::polygon::Polygon::contains

(

std::vector< Point > const &

points

)

const

Returns whether the polygon contains the vector of points.

Definition at line 358 of file Polygon.cc.

                                                                      {
    std::vector<bool> results;
    for (Point const & p : points) {
        results.push_back(contains(p));
    }
    return results;
}

contains() [4/4]

template<typename Xtype , typename Ytype >

bool lsst::afw::geom::polygon::Polygon::contains ( Xtype x, Ytype y ) const

inline

Returns whether the polygon contains the x, y pair.

Definition at line 154 of file Polygon.h.

                                          {
        Point point(x, y);
        return contains(point);
    }

convexHull()

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::convexHull

(

)

const

Produce a polygon from the convex hull.

Definition at line 420 of file Polygon.cc.

                                                 {
    BoostPolygon hull;
    boost::geometry::convex_hull(_impl->poly, hull);
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(hull)));
}

createImage() [1/2]

std::shared_ptr< afw::image::Image< float > > lsst::afw::geom::polygon::Polygon::createImage

(

lsst::geom::Box2I const &

bbox

)

const

Create image of polygon.

Pixels entirely contained within the polygon receive value unity, pixels entirely outside the polygon receive value zero, and pixels on the border receive a value equal to the fraction of the pixel within the polygon.

Note that the center of the lower-left pixel is 0,0.

Definition at line 462 of file Polygon.cc.

                                                                                        {
    using Image = afw::image::Image<float>;
    std::shared_ptr<Image> image = std::make_shared<Image>(bbox);
    image->setXY0(bbox.getMin());
    *image = 0.0;
    lsst::geom::Box2D bounds = getBBox();  // Polygon bounds
    int xMin = std::max(static_cast<int>(bounds.getMinX()), bbox.getMinX());
    int xMax = std::min(static_cast<int>(::ceil(bounds.getMaxX())), bbox.getMaxX());
    int yMin = std::max(static_cast<int>(bounds.getMinY()), bbox.getMinY());
    int yMax = std::min(static_cast<int>(::ceil(bounds.getMaxY())), bbox.getMaxY());
    for (int y = yMin; y <= yMax; ++y) {
        double const yPixelMin = (double)y - 0.5, yPixelMax = (double)y + 0.5;
        BoostPolygon row;  // A polygon of row y
        boost::geometry::assign(
                row, LsstBox(lsst::geom::Point2D(xMin, yPixelMin), lsst::geom::Point2D(xMax, yPixelMax)));
        std::vector<BoostPolygon> intersections;
        boost::geometry::intersection(_impl->poly, row, intersections);
 
        if (intersections.size() == 1 && boost::geometry::num_points(intersections[0]) == 5) {
            // This row is fairly tame, and should have a long run of pixels within the polygon
            BoostPolygon const& row = intersections[0];
            std::vector<double> top, bottom;
            top.reserve(2);
            bottom.reserve(2);
            bool failed = false;
            for (std::vector<Point>::const_iterator i = row.outer().begin(); i != row.outer().end() - 1;
                 ++i) {
                double const xCoord = i->getX(), yCoord = i->getY();
                if (yCoord == yPixelMin) {
                    bottom.push_back(xCoord);
                } else if (yCoord == yPixelMax) {
                    top.push_back(xCoord);
                } else {
                    failed = true;
                    break;
                }
            }
            if (!failed && top.size() == 2 && bottom.size() == 2) {
                std::sort(top.begin(), top.end());
                std::sort(bottom.begin(), bottom.end());
                int const xMin = std::min(top[0], bottom[0]);
                int const xStart = ::ceil(std::max(top[0], bottom[0])) + 1;
                int const xStop = std::min(top[1], bottom[1]) - 1;
                int const xMax = ::ceil(std::max(top[1], bottom[1]));
                pixelRowOverlap(image, _impl->poly, std::max(xMin, bbox.getMinX()),
                                std::min(xStart, bbox.getMaxX()), y);
                int x = xStart;
                for (Image::x_iterator i = image->x_at(std::max(xStart, bbox.getMinX()) - image->getX0(),
                                                       y - image->getY0());
                     x <= std::min(xStop, bbox.getMaxX()); ++i, ++x) {
                    *i = 1.0;
                }
                pixelRowOverlap(image, _impl->poly, std::max(xStop, bbox.getMinX()),
                                std::min(xMax, bbox.getMaxX()), y);
                continue;
            }
        }
 
        // Last resort: do each pixel independently...
        for (auto const &intersection : intersections) {
            double xMinRow = xMax, xMaxRow = xMin;
            std::vector<LsstPoint> const vertices = intersection.outer();
            for (auto const &vertice : vertices) {
                double const x = vertice.getX();
                if (x < xMinRow) xMinRow = x;
                if (x > xMaxRow) xMaxRow = x;
            }
 
            pixelRowOverlap(image, _impl->poly, std::max(static_cast<int>(xMinRow), bbox.getMinX()),
                            std::min(static_cast<int>(::ceil(xMaxRow)), bbox.getMaxX()), y);
        }
    }
    return image;
}

createImage() [2/2]

std::shared_ptr< afw::image::Image< float > > lsst::afw::geom::polygon::Polygon::createImage ( lsst::geom::Extent2I const & extent ) const

inline

Definition at line 261 of file Polygon.h.

                                                                                          {
        return createImage(lsst::geom::Box2I(lsst::geom::Point2I(0, 0), extent));
    }

display()

lsst.afw.geom.polygon.Polygon.display	(		self,
			xy0 = None,
			frame = 1,
			ctype = None )

Display polygon on existing frame

Definition at line 51 of file polygon.py.

    def display(self, xy0=None, frame=1, ctype=None):
        """Display polygon on existing frame"""
        import lsst.geom
        import lsst.afw.display as afwDisplay
        xy0 = lsst.geom.Extent2D(0, 0) if xy0 is None else lsst.geom.Extent2D(xy0)
        disp = afwDisplay.Display(frame=frame)
        with disp.Buffering():
            for p1, p2 in self.getEdges():
                disp.line((p1 - xy0, p2 - xy0), ctype=ctype)
 

dynamicCast()

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< Polygon >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError

if the cast fails

param[in] ptr The pointer to be cast.

Returns

The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError

If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

end()

std::vector< LsstPoint >::const_iterator lsst::afw::geom::polygon::Polygon::end

(

)

const

Definition at line 341 of file Polygon.cc.

                                                      {
    return _impl->poly.outer().end() - 1;  // Note removal of final "closed" point
}

equals()

bool lsst::afw::geom::polygon::Polygon::equals ( typehandling::Storable const & other ) const

overridevirtualnoexcept

Compare this object to another Storable.

Returns

*this == other if other is a Polygon; otherwise false.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 619 of file Polygon.cc.

                                                                     {
    return singleClassEquals(*this, other);
}

getBBox()

Polygon::Box lsst::afw::geom::polygon::Polygon::getBBox

(

)

const

Return bounding box.

Definition at line 314 of file Polygon.cc.

                                  {
    return boostBoxToLsst(boost::geometry::return_envelope<BoostBox>(_impl->poly));
}

getEdges()

std::vector< std::pair< LsstPoint, LsstPoint > > lsst::afw::geom::polygon::Polygon::getEdges

(

)

const

Get vector of edges.

Returns edges, as pairs of vertices.

Definition at line 326 of file Polygon.cc.

                                                                 {
    std::vector<LsstPoint> const vertices = getVertices();
    std::vector<std::pair<LsstPoint, LsstPoint>> edges;
    edges.reserve(getNumEdges());
    for (std::vector<LsstPoint>::const_iterator i = vertices.begin(), j = vertices.begin() + 1;
         j != vertices.end(); ++i, ++j) {
        edges.emplace_back(*i, *j);
    }
    return edges;
}

getNumEdges()

size_t lsst::afw::geom::polygon::Polygon::getNumEdges

(

)

const

Return number of edges.

Identical with the number of points

Definition at line 309 of file Polygon.cc.

                                  {
    // boost::geometry::models::polygon uses a "closed" polygon: the start/end point is included twice
    return boost::geometry::num_points(_impl->poly) - 1;
}

getPersistenceName()

std::string lsst::afw::geom::polygon::Polygon::getPersistenceName ( ) const

overrideprotectedvirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 594 of file Polygon.cc.

{ return getPolygonPersistenceName(); }

getPythonModule()

std::string lsst::afw::table::io::Persistable::getPythonModule ( ) const

protectedvirtualinherited

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented in lsst::afw::image::FilterLabel, lsst::afw::cameraGeom::Detector, lsst::afw::cameraGeom::DetectorCollection, lsst::afw::cameraGeom::TransformMap, lsst::afw::detection::Footprint, lsst::afw::detection::GaussianPsf, lsst::afw::geom::SkyWcs, lsst::afw::geom::SpanSet, lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >, lsst::afw::geom::Transform< afw::geom::Point2Endpoint, afw::geom::GenericEndpoint >, lsst::afw::image::ApCorrMap, lsst::afw::image::CoaddInputs, lsst::afw::image::TransmissionCurve, lsst::afw::math::ChebyshevBoundedField, lsst::afw::math::Function< double >, lsst::afw::math::Function< Kernel::Pixel >, lsst::afw::math::Function< Pixel >, lsst::afw::math::Function< ReturnT >, lsst::afw::math::Kernel, lsst::afw::math::PixelAreaBoundedField, lsst::afw::math::ProductBoundedField, lsst::afw::math::TransformBoundedField, lsst::afw::math::LanczosWarpingKernel, lsst::afw::math::BilinearWarpingKernel, lsst::afw::math::NearestWarpingKernel, lsst::afw::math::WarpingControl, lsst::afw::typehandling::StorableHelper< Base >, lsst::meas::algorithms::CoaddBoundedField, lsst::meas::algorithms::CoaddPsf, lsst::meas::algorithms::KernelPsf, lsst::meas::algorithms::WarpedPsf, lsst::meas::extensions::psfex::PsfexPsf, and lsst::meas::modelfit::Mixture.

Definition at line 36 of file Persistable.cc.

{ return std::string(); }

getVertices()

std::vector< LsstPoint > lsst::afw::geom::polygon::Polygon::getVertices

(

)

const

Get vector of vertices.

Note that the "closed" polygon vertices are returned, so the first and last vertex are identical and there is one more vertex than otherwise expected.

Definition at line 337 of file Polygon.cc.

{ return _impl->poly.outer(); }

hash_value()

std::size_t lsst::afw::geom::polygon::Polygon::hash_value ( ) const

overridevirtualnoexcept

Return a hash of this object.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 349 of file Polygon.cc.

                                             {
    // boost::hash allows hash functions to throw, but the container hashes throw
    // only if the element [geom::Point] has a throwing hash
    static boost::hash<BoostPolygon::ring_type> polygonHash;
    return polygonHash(_impl->poly.outer());
}

intersection() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::intersection

(

Box const &

box

)

const

Definition at line 390 of file Polygon.cc.

                                                                            {
    return _impl->intersection(box);
}

intersection() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::intersection

(

Polygon const &

other

)

const

Returns the intersection of two polygons.

Handles the full range of possibilities.

Definition at line 386 of file Polygon.cc.

                                                                                  {
    return _impl->intersection(other._impl->poly);
}

intersectionSingle() [1/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::intersectionSingle

(

Box const &

box

)

const

Definition at line 382 of file Polygon.cc.

                                                                       {
    return _impl->intersectionSingle(box);
}

intersectionSingle() [2/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::intersectionSingle

(

Polygon const &

other

)

const

Returns the intersection of two polygons.

Does not handle non-convex polygons (which might have multiple independent intersections), and is provided as a convenience for when the polygons are known to be convex (e.g., image borders) and overlapping.

Definition at line 378 of file Polygon.cc.

                                                                             {
    return _impl->intersectionSingle(other._impl->poly);
}

isPersistable()

bool lsst::afw::geom::polygon::Polygon::isPersistable ( ) const

inlineoverridevirtualnoexcept

Whether Polygon is persistable which is always true.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 267 of file Polygon.h.

{ return true; }

operator!=()

bool lsst::afw::geom::polygon::Polygon::operator!= ( Polygon const & other ) const

inline

Definition at line 138 of file Polygon.h.

{ return !(*this == other); }

operator&() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator& ( Box const & rhs ) const

inline

Definition at line 219 of file Polygon.h.

{ return intersection(rhs); }

operator&() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator& ( Polygon const & rhs ) const

inline

Operators for syntactic sugar.

Definition at line 218 of file Polygon.h.

{ return intersection(rhs); }

operator=() [1/2]

Polygon & lsst::afw::geom::polygon::Polygon::operator= ( Polygon && )

default

operator=() [2/2]

Polygon & lsst::afw::geom::polygon::Polygon::operator= ( Polygon const & )

default

operator==()

bool lsst::afw::geom::polygon::Polygon::operator==

(

Polygon const &

other

)

const

Definition at line 345 of file Polygon.cc.

                                                   {
    return boost::geometry::equals(_impl->poly, other._impl->poly);
}

operator^() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator^ ( Box const & rhs ) const

inline

Definition at line 223 of file Polygon.h.

{ return symDifference(rhs); }

operator^() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator^ ( Polygon const & rhs ) const

inline

Definition at line 222 of file Polygon.h.

{ return symDifference(rhs); }

operator|() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator| ( Box const & rhs ) const

inline

Definition at line 221 of file Polygon.h.

{ return union_(rhs); }

operator|() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::operator| ( Polygon const & rhs ) const

inline

Definition at line 220 of file Polygon.h.

{ return union_(rhs); }

overlaps() [1/2]

bool lsst::afw::geom::polygon::Polygon::overlaps

(

Box const &

box

)

const

Definition at line 376 of file Polygon.cc.

{ return _impl->overlaps(box); }

overlaps() [2/2]

bool lsst::afw::geom::polygon::Polygon::overlaps

(

Polygon const &

other

)

const

Returns whether the polygons overlap each other.

Note that there may be no intersection if the polygons only share a boundary.

Definition at line 374 of file Polygon.cc.

{ return _impl->overlaps(other._impl->poly); }

plot()

lsst.afw.geom.polygon.Polygon.plot	(		self,
			axes = None,
		**	kwargs )

Plot polygon with matplotlib

Parameters
----------
axes : `matplotlib.axes.Axes`
    Matplotlib axes to use, or None
kwargs : any
    Additional arguments to `matplotlib.axes.Axes.plot`
    or `matplotlib.axes.Axes.scatter`.

Returns
-------
axes : `matplotlib.axes.Axes`
    The axes used to make the plot (same as ``axes``, if provided).

Definition at line 61 of file polygon.py.

    def plot(self, axes=None, **kwargs):
        """Plot polygon with matplotlib
 
        Parameters
        ----------
        axes : `matplotlib.axes.Axes`
            Matplotlib axes to use, or None
        kwargs : any
            Additional arguments to `matplotlib.axes.Axes.plot`
            or `matplotlib.axes.Axes.scatter`.
 
        Returns
        -------
        axes : `matplotlib.axes.Axes`
            The axes used to make the plot (same as ``axes``, if provided).
        """
        import numpy
        if axes is None:
            import matplotlib.pyplot as plt
            plt.figure()
            axes = plt.axes()
        for p1, p2 in self.getEdges():
            x = (p1.getX(), p2.getX())
            y = (p1.getY(), p2.getY())
            axes.plot(x, y, **kwargs)
        vertices = self.getVertices()
        x = numpy.array([p[0] for p in vertices])
        y = numpy.array([p[1] for p in vertices])
        axes.scatter(x, y, **kwargs)
        return axes

readFits() [1/3]

static std::shared_ptr< Polygon > lsst::afw::table::io::PersistableFacade< Polygon >::readFits ( fits::Fits & fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in]

fitsfile

FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

readFits() [2/3]

static std::shared_ptr< Polygon > lsst::afw::table::io::PersistableFacade< Polygon >::readFits ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

readFits() [3/3]

static std::shared_ptr< Polygon > lsst::afw::table::io::PersistableFacade< Polygon >::readFits ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

simplify()

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::simplify

(

double const

distance

)

const

Return a simplified polygon.

Removes unnecessary points (using the Douglas-Peucker algorithm).

Definition at line 414 of file Polygon.cc.

                                                                    {
    BoostPolygon result;
    boost::geometry::simplify(_impl->poly, result, distance);
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(result)));
}

singleClassEquals()

template<class T >

static bool lsst::afw::typehandling::Storable::singleClassEquals ( T const & lhs, Storable const & rhs )

inlinestaticprotectedinherited

Test if a Storable is of a particular class and equal to another object.

This method template simplifies implementations of equals that delegate to operator== without supporting cross-class comparisons.

Template Parameters

T	The class expected of the two objects to be compared.

Parameters

lhs,rhs

The objects to compare. Note that rhs need not be a T, while lhs must be.

Returns

true if rhs is a T and lhs == rhs; false otherwise.

Exception Safety

Provides the same level of exception safety as operator==. Most implementations of operator== do not throw.

Note

This method template calls operator== with both arguments of compile-time type T const&. Its use is not recommended if there would be any ambiguity as to which operator== gets picked by overload resolution.

This method template is typically called from equals as:

bool MyType::equals(Storable const& other) const noexcept {
    return singleClassEquals(*this, other);
}

Definition at line 151 of file Storable.h.

                                                                     {
        auto typedRhs = dynamic_cast<T const*>(&rhs);
        if (typedRhs != nullptr) {
            return lhs == *typedRhs;
        } else {
            return false;
        }
    }

subSample() [1/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::subSample

(

double

maxLength

)

const

Definition at line 450 of file Polygon.cc.

                                                                {
    std::vector<LsstPoint> vertices;  // New vertices
    vertices.reserve(getNumEdges() + static_cast<size_t>(::ceil(calculatePerimeter() / maxLength)));
    std::vector<std::pair<Point, Point>> edges = getEdges();
    for (auto const &edge : edges) {
        Point const &p1 = edge.first, p2 = edge.second;
        double const dist = ::sqrt(p1.distanceSquared(p2));
        addSubSampledEdge(vertices, p1, p2, static_cast<size_t>(::ceil(dist / maxLength)));
    }
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(vertices)));
}

subSample() [2/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::subSample

(

size_t

num

)

const

Sub-sample each edge.

This should provide greater fidelity when transforming with a non-linear transform.

Definition at line 440 of file Polygon.cc.

                                                          {
    std::vector<LsstPoint> vertices;  // New vertices
    vertices.reserve(getNumEdges() * num);
    std::vector<std::pair<Point, Point>> edges = getEdges();
    for (auto const &edge : edges) {
        addSubSampledEdge(vertices, edge.first, edge.second, num);
    }
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(vertices)));
}

swap()

void lsst::afw::geom::polygon::Polygon::swap ( Polygon & other )

inlinenoexcept

Swap two polygons.

Definition at line 102 of file Polygon.h.

{ std::swap(this->_impl, other._impl); }

symDifference() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::symDifference

(

Box const &

box

)

const

Definition at line 410 of file Polygon.cc.

                                                                             {
    return _impl->symDifference(box);
}

symDifference() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::symDifference

(

Polygon const &

other

)

const

Return the symmetric difference of two polygons.

Definition at line 406 of file Polygon.cc.

                                                                                   {
    return _impl->symDifference(other._impl->poly);
}

toString()

std::string lsst::afw::geom::polygon::Polygon::toString ( ) const

overridevirtual

Create a string representation of this object.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 613 of file Polygon.cc.

                                  {
    std::stringstream buffer;
    buffer << "Polygon(" << this->getVertices() << ")";
    return buffer.str();
}

transform() [1/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::transform

(

lsst::geom::AffineTransform const &

transform

)

const

Parameters

transform

Transform from original to target frame

Definition at line 431 of file Polygon.cc.

                                                                                        {
    std::vector<LsstPoint> vertices;  // New vertices
    vertices.reserve(getNumEdges());
    for (auto const &i : _impl->poly.outer()) {
        vertices.push_back(transform(i));
    }
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(vertices)));
}

transform() [2/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::transform

(

TransformPoint2ToPoint2 const &

transform

)

const

Transform the polygon.

The transformation is only applied to the vertices. If the transformation is non-linear, the edges will not reflect that, but simply join the vertices. Greater fidelity might be achieved by using "subSample" before transforming.

Parameters

transform

Transform from original to target frame

Definition at line 426 of file Polygon.cc.

                                                                                        {
    auto newVertices = transform.applyForward(getVertices());
    return std::shared_ptr<Polygon>(new Polygon(std::make_shared<Impl>(newVertices)));
}

union_() [1/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::union_

(

Box const &

box

)

const

Definition at line 404 of file Polygon.cc.

{ return _impl->union_(box); }

union_() [2/2]

std::vector< std::shared_ptr< Polygon > > lsst::afw::geom::polygon::Polygon::union_

(

Polygon const &

other

)

const

Returns the union of two polygons.

Handles the full range of possibilities.

Note the trailing underscore in C++, due to "union" being a reserved word.

Definition at line 400 of file Polygon.cc.

                                                                            {
    return _impl->union_(other._impl->poly);
}

unionSingle() [1/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::unionSingle

(

Box const &

box

)

const

Definition at line 398 of file Polygon.cc.

{ return _impl->unionSingle(box); }

unionSingle() [2/2]

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::unionSingle

(

Polygon const &

other

)

const

Returns the union of two polygons.

Does not handle non-overlapping polygons, the union of which would be disjoint.

Definition at line 394 of file Polygon.cc.

                                                                      {
    return _impl->unionSingle(other._impl->poly);
}

write()

void lsst::afw::geom::polygon::Polygon::write ( OutputArchiveHandle & handle ) const

overrideprotectedvirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 596 of file Polygon.cc.

                                                     {
    static PolygonSchema const& keys = PolygonSchema::get();
    afw::table::BaseCatalog catalog = handle.makeCatalog(keys.schema);
 
    std::vector<LsstPoint> vertices = this->getVertices();
    for (auto const &vertice : vertices) {
        std::shared_ptr<afw::table::BaseRecord> record = catalog.addNew();
        record->set(keys.vertices, vertice);
    }
 
    handle.saveCatalog(catalog);
}

writeFits() [1/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::Fits & fitsfile ) const

inherited

Write the object to an already-open FITS object.

Parameters

[in]

fitsfile

Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

                                                    {
    OutputArchive archive;
    archive.put(this);
    archive.writeFits(fitsfile);
}

writeFits() [2/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::MemFileManager & manager, std::string const & mode = "w" ) const

inherited

Write the object to a FITS image in memory.

Parameters

[in]	manager	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

                                                                                    {
    fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

writeFits() [3/3]

void lsst::afw::table::io::Persistable::writeFits ( std::string const & fileName, std::string const & mode = "w" ) const

inherited

Write the object to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

                                                                                  {
    fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

Friends And Related Symbol Documentation

operator<<()

std::ostream & operator<< ( std::ostream & os, Storable const & storable )

related

Output operator for Storable.

Parameters

os	the desired output stream
storable	the object to print

Returns

a reference to os

Exceptions

UnsupportedOperationException

Thrown if storable does not have an implementation of Storable::toString.

Definition at line 174 of file Storable.h.

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

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/include/lsst/afw/geom/polygon/Polygon.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/python/lsst/afw/geom/polygon.py
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/geom/polygon/Polygon.cc