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

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

	Polygon (Box const &box, lsst::geom::AffineTransform const &transform)
	Construct a 4-sided Polygon from a transformed box. More...

	Polygon (std::vector< Point > const &vertices)
	Construct a Polygon from a list of vertices. More...

void	swap (Polygon &other) noexcept
	Swap two polygons. More...

size_t	getNumEdges () const
	Return number of edges. More...

Box	getBBox () const
	Return bounding box. More...

Point	calculateCenter () const

double	calculateArea () const

double	calculatePerimeter () const

std::vector< Point >	getVertices () const
	Get vector of vertices. More...

std::vector< Point >::const_iterator	begin () const
	Iterator for vertices. More...

std::vector< Point >::const_iterator	end () const

std::vector< std::pair< Point, Point > >	getEdges () const
	Get vector of edges. More...

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

bool	contains (Point const &point) const
	Returns whether the polygon contains the point. More...

bool	overlaps (Polygon const &other) const
	Returns whether the polygons overlap each other. More...

bool	overlaps (Box const &box) const

std::shared_ptr< Polygon >	intersectionSingle (Polygon const &other) const
	Returns the intersection of two polygons. More...

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

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

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

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

std::vector< std::shared_ptr< Polygon > >	symDifference (Box const &box) const

std::shared_ptr< Polygon >	simplify (double const distance) const
	Return a simplified polygon. More...

std::vector< std::shared_ptr< Polygon > >	operator& (Polygon const &rhs) const
	Operators for syntactic sugar. More...

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

std::shared_ptr< Polygon >	transform (TransformPoint2ToPoint2 const &transform) const
	Transform the polygon. More...

std::shared_ptr< Polygon >	transform (lsst::geom::AffineTransform const &transform) const

std::shared_ptr< Polygon >	subSample (size_t num) const
	Sub-sample each edge. More...

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

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

std::shared_ptr< typehandling::Storable >	cloneStorable () const override
	Create a new Polygon that is a copy of this one. More...

std::string	toString () const override
	Create a string representation of this object. More...

bool	equals (typehandling::Storable const &other) const noexcept override
	Compare this object to another Storable. More...

def	__repr__ (self)

def	__reduce__ (self)

def	__iter__ (self)

def	__getitem__ (self, i)

def	__len__ (self)

def	__contains__ (self, point)

def	display (self, xy0=None, frame=1, ctype=None)

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

void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory. More...

void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object. More...

Static Public Member Functions
static std::shared_ptr< Polygon >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...

static std::shared_ptr< Polygon >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file. More...

static std::shared_ptr< Polygon >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory. More...

static std::shared_ptr< Polygon >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr. More...

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

void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs. More...

virtual std::string	getPythonModule () const
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered. More...

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

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

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.

288 : _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.

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

vertices

afw::table::PointKey< double > vertices

Definition: Polygon.cc:530

Member Function Documentation

◆ contains()

def 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()

def 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()

def 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()

def lsst.afw.geom.polygon.Polygon.__len__ ( self )

Definition at line 44 of file polygon.py.

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

◆ reduce()

def lsst.afw.geom.polygon.Polygon.__reduce__ ( self )

Definition at line 33 of file polygon.py.

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

◆ repr()

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

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

◆ calculateArea()

double lsst::afw::geom::polygon::Polygon::calculateArea ( ) const

Definition at line 322 of file Polygon.cc.

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

324 { 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 593 of file Polygon.cc.

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

◆ contains()

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.

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

◆ convexHull()

std::shared_ptr< Polygon > lsst::afw::geom::polygon::Polygon::convexHull ( ) const

Produce a polygon from the convex hull.

Definition at line 404 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 446 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 248 of file Polygon.h.

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

◆ display()

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

                                                                                         {
     auto result = std::dynamic_pointer_cast<T>(ptr);
     if (!result) {
         throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
     }
     return result;
 }

◆ 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 603 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 578 of file Polygon.cc.

578 { 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::meas::modelfit::Mixture, lsst::meas::algorithms::WarpedPsf, lsst::meas::algorithms::KernelPsf, lsst::meas::algorithms::CoaddPsf, lsst::meas::algorithms::CoaddBoundedField, lsst::afw::typehandling::StorableHelper< Base >, lsst::afw::math::WarpingControl, lsst::afw::math::NearestWarpingKernel, lsst::afw::math::BilinearWarpingKernel, lsst::afw::math::LanczosWarpingKernel, lsst::afw::math::TransformBoundedField, lsst::afw::math::ProductBoundedField, lsst::afw::math::PixelAreaBoundedField, lsst::afw::math::Kernel, lsst::afw::math::Function< ReturnT >, lsst::afw::math::ChebyshevBoundedField, lsst::afw::image::TransmissionCurve, lsst::afw::image::CoaddInputs, lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >, lsst::afw::geom::Transform< afw::geom::Point2Endpoint, afw::geom::GenericEndpoint >, lsst::afw::geom::SkyWcs, lsst::afw::detection::GaussianPsf, lsst::afw::detection::Footprint, lsst::afw::cameraGeom::DetectorCollection, and lsst::afw::image::FilterLabel.

Definition at line 36 of file Persistable.cc.

36 { return std::string(); }

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.

337 { 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 374 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 370 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 366 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 362 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 254 of file Polygon.h.

254 { return true; }

◆ operator!=()

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

inline

Definition at line 138 of file Polygon.h.

138 { 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 206 of file Polygon.h.

206 { 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 205 of file Polygon.h.

205 { 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 210 of file Polygon.h.

210 { return symDifference(rhs); }

lsst::afw::geom::polygon::Polygon::symDifference

std::vector< std::shared_ptr< Polygon > > symDifference(Polygon const &other) const

Return the symmetric difference of two polygons.

Definition: Polygon.cc:390

◆ operator^() [2/2]

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

inline

Definition at line 209 of file Polygon.h.

209 { 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 208 of file Polygon.h.

208 { return union_(rhs); }

lsst::afw::geom::polygon::Polygon::union_

std::vector< std::shared_ptr< Polygon > > union_(Polygon const &other) const

Returns the union of two polygons.

Definition: Polygon.cc:384

◆ operator|() [2/2]

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

inline

Definition at line 207 of file Polygon.h.

207 { return union_(rhs); }

◆ overlaps() [1/2]

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

Definition at line 360 of file Polygon.cc.

360 { return _impl->overlaps(box); }

lsst::afw::geom::polygon::Polygon::Impl::overlaps

bool overlaps(PolyT const &other) const

Definition: Polygon.cc:200

◆ 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 358 of file Polygon.cc.

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

◆ plot()

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

                                                          {
         return dynamicCast(Persistable::_readFits(fitsfile));
     }

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

                                                                                              {
         return dynamicCast(Persistable::_readFits(manager, hdu));
     }

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

                                                                                            {
         return dynamicCast(Persistable::_readFits(fileName, hdu));
     }

◆ 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 398 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 434 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 424 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.

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

std::swap

T swap(T... args)

◆ symDifference() [1/2]

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

Definition at line 394 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 390 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 597 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 415 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 410 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 388 of file Polygon.cc.

388 { return _impl->union_(box); }

lsst::afw::geom::polygon::Polygon::Impl::union_

std::vector< std::shared_ptr< Polygon > > union_(PolyT const &other) const

Definition: Polygon.cc:268

◆ 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 384 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 382 of file Polygon.cc.

382 { return _impl->unionSingle(box); }

lsst::afw::geom::polygon::Polygon::Impl::unionSingle

std::shared_ptr< Polygon > unionSingle(PolyT const &other) const

Definition: Polygon.cc:256

◆ 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 378 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 580 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 Function Documentation

◆ operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		Storable const &	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-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/include/lsst/afw/geom/polygon/Polygon.h
/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/python/lsst/afw/geom/polygon.py
/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/src/geom/polygon/Polygon.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Related Functions

Detailed Description

Member Typedef Documentation

◆ Box

◆ OutputArchiveHandle

◆ Point

Constructor & Destructor Documentation

◆ Polygon() [1/6]

◆ Polygon() [2/6]

◆ Polygon() [3/6]

◆ ~Polygon()

◆ Polygon() [4/6]

◆ Polygon() [5/6]

◆ Polygon() [6/6]

Member Function Documentation

◆ __contains__()

◆ __getitem__()

◆ __iter__()

◆ __len__()

◆ __reduce__()

◆ __repr__()

◆ begin()

◆ calculateArea()

◆ calculateCenter()

◆ calculatePerimeter()

◆ cloneStorable()

◆ contains()

◆ convexHull()

◆ createImage() [1/2]

◆ createImage() [2/2]

◆ display()

◆ dynamicCast()

◆ end()

◆ equals()

◆ getBBox()

◆ getEdges()

◆ getNumEdges()

◆ getPersistenceName()

◆ getPythonModule()

◆ getVertices()

◆ hash_value()

◆ intersection() [1/2]

◆ intersection() [2/2]

◆ intersectionSingle() [1/2]

◆ intersectionSingle() [2/2]

◆ isPersistable()

◆ operator!=()

◆ operator&() [1/2]

◆ operator&() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ operator^() [1/2]

◆ operator^() [2/2]

◆ operator|() [1/2]

◆ operator|() [2/2]

◆ overlaps() [1/2]

◆ overlaps() [2/2]

◆ plot()

◆ readFits() [1/3]

◆ readFits() [2/3]

◆ readFits() [3/3]

◆ simplify()

◆ singleClassEquals()

◆ subSample() [1/2]

◆ subSample() [2/2]

◆ swap()

◆ symDifference() [1/2]

◆ symDifference() [2/2]

◆ toString()

◆ transform() [1/2]

◆ transform() [2/2]

◆ union_() [1/2]

◆ contains()

◆ getitem()

◆ iter()

◆ len()

◆ reduce()

◆ repr()