lsst::sphgeom::ConvexPolygon Class Reference

ConvexPolygon is a closed convex polygon on the unit sphere. More...

#include <ConvexPolygon.h>

Inheritance diagram for lsst::sphgeom::ConvexPolygon:

Public Member Functions
	ConvexPolygon (std::vector< UnitVector3d > const &points)
	This constructor creates a convex polygon that is the convex hull of the given set of points.
	ConvexPolygon (UnitVector3d const &v0, UnitVector3d const &v1, UnitVector3d const &v2)
	This constructor creates a triangle with the given vertices.
	ConvexPolygon (UnitVector3d const &v0, UnitVector3d const &v1, UnitVector3d const &v2, UnitVector3d const &v3)
	This constructor creates a quadrilateral with the given vertices.
bool	operator== (ConvexPolygon const &p) const
	Two convex polygons are equal iff they contain the same points.
bool	operator!= (ConvexPolygon const &p) const
std::vector< UnitVector3d > const &	getVertices () const
UnitVector3d	getCentroid () const
	The centroid of a polygon is its center of mass projected onto S², assuming a uniform mass distribution over the polygon surface.
std::unique_ptr< Region >	clone () const override
	clone returns a deep copy of this region.
bool	isEmpty () const override
	isEmpty returns true when a region does not contain any points.
Box	getBoundingBox () const override
	getBoundingBox returns a bounding-box for this region.
Box3d	getBoundingBox3d () const override
	getBoundingBox3d returns a 3-dimensional bounding-box for this region.
Circle	getBoundingCircle () const override
	getBoundingCircle returns a bounding-circle for this region.
Relationship	relate (Region const &r) const override
Relationship	relate (Box const &) const override
Relationship	relate (Circle const &) const override
Relationship	relate (ConvexPolygon const &) const override
Relationship	relate (Ellipse const &) const override
TriState	overlaps (Region const &other) const override
TriState	overlaps (Box const &) const override
TriState	overlaps (Circle const &) const override
TriState	overlaps (ConvexPolygon const &) const override
TriState	overlaps (Ellipse const &) const override
std::vector< std::uint8_t >	encode () const override
	encode serializes this region into an opaque byte string.
virtual bool	contains (UnitVector3d const &) const=0
	contains tests whether the given unit vector is inside this region.
bool	contains (double x, double y, double z) const
	contains tests whether the unit vector defined by the given (not necessarily normalized) coordinates is inside this region.
bool	contains (double lon, double lat) const
	contains tests whether the unit vector defined by the given longitude and latitude coordinates (in radians) is inside this region.
bool	contains (UnitVector3d const &v) const override
bool	contains (Region const &r) const
bool	isDisjointFrom (Region const &r) const
bool	intersects (Region const &r) const
bool	isWithin (Region const &r) const

Static Public Member Functions
static ConvexPolygon	convexHull (std::vector< UnitVector3d > const &points)
	convexHull returns the convex hull of the given set of points if it exists and throws an exception otherwise.
static std::vector< std::unique_ptr< Region > >	getRegions (Region const &region)
	getRegions returns a vector of Region.
static std::unique_ptr< ConvexPolygon >	decode (std::vector< std::uint8_t > const &s)
static std::unique_ptr< ConvexPolygon >	decode (std::uint8_t const *buffer, size_t n)
static std::unique_ptr< Region >	decodeBase64 (std::string const &s)
static std::unique_ptr< Region >	decodeBase64 (std::string_view const &s)
static TriState	decodeOverlapsBase64 (std::string const &s)
static TriState	decodeOverlapsBase64 (std::string_view const &s)

Static Public Attributes
static constexpr std::uint8_t	TYPE_CODE = 'p'

Static Protected Member Functions
static TriState	_relationship_to_overlaps (Relationship r)

Detailed Description

ConvexPolygon is a closed convex polygon on the unit sphere.

Its edges are great circles (geodesics), and the shorter of the two great circle segments between any two points on the polygon boundary is contained in the polygon.

The vertices of a convex polygon are distinct and have counter-clockwise orientation when viewed from outside the unit sphere. No three consecutive vertices are coplanar and edges do not intersect except at vertices.

Furthermore, if a convex polygon contains a point p of S², then we require that it be disjoint from point -p. This guarantees the existence of a unique shortest great circle segment between any 2 points contained in the polygon, but means e.g. that hemispheres and lunes cannot be represented by convex polygons.

Currently, the only way to construct a convex polygon is to compute the convex hull of a point set.

Definition at line 65 of file ConvexPolygon.h.

Constructor & Destructor Documentation

ConvexPolygon() [1/3]

lsst::sphgeom::ConvexPolygon::ConvexPolygon ( std::vector< UnitVector3d > const & points )

explicit

This constructor creates a convex polygon that is the convex hull of the given set of points.

Definition at line 262 of file ConvexPolygon.cc.

                                                                   :
    _vertices(points)
{
    computeHull(_vertices);
}

ConvexPolygon() [2/3]

lsst::sphgeom::ConvexPolygon::ConvexPolygon ( UnitVector3d const & v0, UnitVector3d const & v1, UnitVector3d const & v2 )

inline

This constructor creates a triangle with the given vertices.

It is assumed that orientation(v0, v1, v2) = 1. Use with caution - for performance reasons, this is not verified!

Definition at line 85 of file ConvexPolygon.h.

                                           :
        _vertices{v0, v1, v2}
    {}

ConvexPolygon() [3/3]

lsst::sphgeom::ConvexPolygon::ConvexPolygon ( UnitVector3d const & v0, UnitVector3d const & v1, UnitVector3d const & v2, UnitVector3d const & v3 )

inline

This constructor creates a quadrilateral with the given vertices.

It is assumed that orientation(v0, v1, v2), orientation(v1, v2, v3), orientation(v2, v3, v0), and orientation (v3, v0, v1) are all 1. Use with caution - for performance reasons, this is not verified!

Definition at line 96 of file ConvexPolygon.h.

                                           :
        _vertices{v0, v1, v2, v3}
    {}

Member Function Documentation

_relationship_to_overlaps()

static TriState lsst::sphgeom::Region::_relationship_to_overlaps ( Relationship r )

inlinestaticprotectedinherited

Definition at line 206 of file Region.h.

                                                              {
        // `relate` returns exact relation when specific bit is set, if it is
        // not then relation may be true or not.
        if ((r & DISJOINT) == DISJOINT) {
            return TriState(false);
        }
        if ((r & (WITHIN | CONTAINS)).any()) {
            return TriState(true);
        }
        return TriState();
    }

clone()

std::unique_ptr< Region > lsst::sphgeom::ConvexPolygon::clone ( ) const

inlineoverridevirtual

clone returns a deep copy of this region.

Implements lsst::sphgeom::Region.

Definition at line 116 of file ConvexPolygon.h.

                                                 {
        return std::unique_ptr<ConvexPolygon>(new ConvexPolygon(*this));
    }

contains() [1/5]

bool lsst::sphgeom::Region::contains	(	double	lon,
		double	lat ) const

contains tests whether the unit vector defined by the given longitude and latitude coordinates (in radians) is inside this region.

Definition at line 117 of file Region.cc.

                                                  {
    return contains(UnitVector3d(LonLat::fromRadians(lon, lat)));
}

contains() [2/5]

bool lsst::sphgeom::Region::contains	(	double	x,
		double	y,
		double	z ) const

contains tests whether the unit vector defined by the given (not necessarily normalized) coordinates is inside this region.

Definition at line 113 of file Region.cc.

                                                        {
    return contains(UnitVector3d(x, y, z));
}

contains() [3/5]

bool lsst::sphgeom::ConvexPolygon::contains

(

Region const &

r

)

const

contains returns true if the intersection of this convex polygon and x is equal to x.

Definition at line 328 of file ConvexPolygon.cc.

                                                   {
    return (relate(r) & CONTAINS) != 0;
}

contains() [4/5]

virtual bool lsst::sphgeom::Region::contains ( UnitVector3d const & ) const

virtual

contains tests whether the given unit vector is inside this region.

Implements lsst::sphgeom::Region.

contains() [5/5]

bool lsst::sphgeom::ConvexPolygon::contains ( UnitVector3d const & v ) const

overridevirtual

contains returns true if the intersection of this convex polygon and x is equal to x.

Implements lsst::sphgeom::Region.

Definition at line 324 of file ConvexPolygon.cc.

                                                         {
    return detail::contains(_vertices.begin(), _vertices.end(), v);
}

convexHull()

static ConvexPolygon lsst::sphgeom::ConvexPolygon::convexHull ( std::vector< UnitVector3d > const & points )

inlinestatic

convexHull returns the convex hull of the given set of points if it exists and throws an exception otherwise.

Though points are supplied in a vector, they really are conceptually a set - the ConvexPolygon returned is invariant under permutation of the input array.

Definition at line 73 of file ConvexPolygon.h.

                                                                            {
        return ConvexPolygon(points);
    }

decode() [1/2]

std::unique_ptr< ConvexPolygon > lsst::sphgeom::ConvexPolygon::decode ( std::uint8_t const * buffer, size_t n )

static

decode deserializes a ConvexPolygon from a byte string produced by encode.

Definition at line 393 of file ConvexPolygon.cc.

{
    if (buffer == nullptr || *buffer != TYPE_CODE ||
        n < 1 + 24*3 || (n - 1) % 24 != 0) {
        throw std::runtime_error("Byte-string is not an encoded ConvexPolygon");
    }
    std::unique_ptr<ConvexPolygon> poly(new ConvexPolygon);
    ++buffer;
    size_t nv = (n - 1) / 24;
    poly->_vertices.reserve(nv);
    for (size_t i = 0; i < nv; ++i, buffer += 24) {
        poly->_vertices.push_back(UnitVector3d::fromNormalized(
            decodeDouble(buffer),
            decodeDouble(buffer + 8),
            decodeDouble(buffer + 16)
        ));
    }
    return poly;
}

decode() [2/2]

static std::unique_ptr< ConvexPolygon > lsst::sphgeom::ConvexPolygon::decode ( std::vector< std::uint8_t > const & s )

inlinestatic

decode deserializes a ConvexPolygon from a byte string produced by encode.

Definition at line 175 of file ConvexPolygon.h.

                                                                                {
        return decode(s.data(), s.size());
    }

decodeBase64() [1/2]

static std::unique_ptr< Region > lsst::sphgeom::Region::decodeBase64 ( std::string const & s )

inlinestaticinherited

decodeBase64 deserializes a Region from an ASCII string produced by encode and then base64-encoding that result.

This method also interprets ':' as a delimiter for the elements of a UnionRegion, to support cases where a union of region is constructed server-side in a database as a concatenation with that delimiter.

Definition at line 176 of file Region.h.

                                                                   {
        return decodeBase64(s);
    }

decodeBase64() [2/2]

std::unique_ptr< Region > lsst::sphgeom::Region::decodeBase64 ( std::string_view const & s )

staticinherited

decodeBase64 deserializes a Region from an ASCII string produced by encode and then base64-encoding that result.

This method also interprets ':' as a delimiter for the elements of a UnionRegion, to support cases where a union of region is constructed server-side in a database as a concatenation with that delimiter.

Definition at line 93 of file Region.cc.

                                                                   {
    if (s.empty()) {
        return std::unique_ptr<UnionRegion>(new UnionRegion({}));
    }
    auto region_begin = s.begin();
    auto region_end = std::find(s.begin(), s.end(), ':');
    if (region_end != s.end()) {
        std::vector<std::unique_ptr<Region>> union_args;
        while (region_end != s.end()) {
            auto bytes = base64::decode_into<std::vector<std::uint8_t>>(region_begin, region_end);
            union_args.push_back(decode(bytes));
            region_begin = region_end;
            ++region_begin;
            region_end = std::find(region_begin, s.end(), ':');
        }
        auto bytes = base64::decode_into<std::vector<std::uint8_t>>(region_begin, region_end);
        union_args.push_back(decode(bytes));
        return std::unique_ptr<UnionRegion>(new UnionRegion(std::move(union_args)));
    } else {
        auto bytes = base64::decode_into<std::vector<std::uint8_t>>(region_begin, region_end);
        return decode(bytes);
    }
}

decodeOverlapsBase64() [1/2]

static TriState lsst::sphgeom::Region::decodeOverlapsBase64 ( std::string const & s )

inlinestaticinherited

decodeOverlapsBase64 evaluates an encoded overlap expression.

A single overlap expression is formed by concatenating a pair of base64-encoded regions (Region::encode then base64 encoding) with '&' as the delimiter. Multiple such pairwise overlap expressions can then be concatenated with '|' as the delimiter to form the logical OR.

Definition at line 190 of file Region.h.

                                                              {
        return decodeOverlapsBase64(s);
    }

decodeOverlapsBase64() [2/2]

TriState lsst::sphgeom::Region::decodeOverlapsBase64 ( std::string_view const & s )

staticinherited

decodeOverlapsBase64 evaluates an encoded overlap expression.

A single overlap expression is formed by concatenating a pair of base64-encoded regions (Region::encode then base64 encoding) with '&' as the delimiter. Multiple such pairwise overlap expressions can then be concatenated with '|' as the delimiter to form the logical OR.

Definition at line 117 of file Region.cc.

                                                              {
    TriState result(false);
    if (s.empty()) {
        // False makes the most sense as the limit of a logical OR of zero
        // terms (e.g. `any([])` in Python).
        return result;
    }
    auto begin = s.begin();
    while (result != true) {  // if result is known to be true, we're done.
        auto mid = std::find(begin, s.end(), '&');
        if (mid == s.end()) {
            throw std::runtime_error("No '&' found in encoded overlap expression term.");
        }
        auto a = Region::decode(base64::decode_into<std::vector<std::uint8_t>>(begin, mid));
        ++mid;
        auto end = std::find(mid, s.end(), '|');
        auto b = Region::decode(base64::decode_into<std::vector<std::uint8_t>>(mid, end));
        result = result | a->overlaps(*b);
        if (end == s.end()) {
            break;
        } else {
            begin = end;
            ++begin;
        }
    }
    return result;
}

encode()

std::vector< std::uint8_t > lsst::sphgeom::ConvexPolygon::encode ( ) const

overridevirtual

encode serializes this region into an opaque byte string.

Byte strings emitted by encode can be deserialized with decode.

Implements lsst::sphgeom::Region.

Definition at line 380 of file ConvexPolygon.cc.

                                                  {
    std::vector<std::uint8_t> buffer;
    std::uint8_t tc = TYPE_CODE;
    buffer.reserve(1 + 24 * _vertices.size());
    buffer.push_back(tc);
    for (UnitVector3d const & v: _vertices) {
        encodeDouble(v.x(), buffer);
        encodeDouble(v.y(), buffer);
        encodeDouble(v.z(), buffer);
    }
    return buffer;
}

getBoundingBox()

Box lsst::sphgeom::ConvexPolygon::getBoundingBox ( ) const

overridevirtual

getBoundingBox returns a bounding-box for this region.

Implements lsst::sphgeom::Region.

Definition at line 316 of file ConvexPolygon.cc.

                                        {
    return detail::boundingBox(_vertices.begin(), _vertices.end());
}

getBoundingBox3d()

Box3d lsst::sphgeom::ConvexPolygon::getBoundingBox3d ( ) const

overridevirtual

getBoundingBox3d returns a 3-dimensional bounding-box for this region.

Implements lsst::sphgeom::Region.

Definition at line 320 of file ConvexPolygon.cc.

                                            {
    return detail::boundingBox3d(_vertices.begin(), _vertices.end());
}

getBoundingCircle()

Circle lsst::sphgeom::ConvexPolygon::getBoundingCircle ( ) const

overridevirtual

getBoundingCircle returns a bounding-circle for this region.

Implements lsst::sphgeom::Region.

Definition at line 312 of file ConvexPolygon.cc.

                                              {
    return detail::boundingCircle(_vertices.begin(), _vertices.end());
}

getCentroid()

UnitVector3d lsst::sphgeom::ConvexPolygon::getCentroid

(

)

const

The centroid of a polygon is its center of mass projected onto S², assuming a uniform mass distribution over the polygon surface.

Definition at line 308 of file ConvexPolygon.cc.

                                              {
    return detail::centroid(_vertices.begin(), _vertices.end());
}

getRegions()

std::vector< std::unique_ptr< Region > > lsst::sphgeom::Region::getRegions ( Region const & region )

staticinherited

getRegions returns a vector of Region.

Definition at line 145 of file Region.cc.

                                                                        {
    std::vector<std::unique_ptr<Region>> result;
    if (auto union_region = dynamic_cast<UnionRegion const *>(&region)) {
        for(unsigned i = 0; i < union_region->nOperands(); ++i) {
            result.emplace_back(union_region->getOperand(i).clone());
        }
    } else if(auto intersection_region = dynamic_cast<IntersectionRegion const *>(&region)) {
        for(unsigned i = 0; i < intersection_region->nOperands(); ++i) {
            result.emplace_back(intersection_region->getOperand(i).clone());
        }
    } else {
        result.emplace_back(region.clone());
    }
    return result;
}

getVertices()

std::vector< UnitVector3d > const & lsst::sphgeom::ConvexPolygon::getVertices ( ) const

inline

Definition at line 107 of file ConvexPolygon.h.

                                                        {
        return _vertices;
    }

intersects()

bool lsst::sphgeom::ConvexPolygon::intersects

(

Region const &

r

)

const

intersects returns true if the intersection of this convex polygon and x is non-empty.

Definition at line 336 of file ConvexPolygon.cc.

                                                     {
    return !isDisjointFrom(r);
}

isDisjointFrom()

bool lsst::sphgeom::ConvexPolygon::isDisjointFrom

(

Region const &

r

)

const

isDisjointFrom returns true if the intersection of this convex polygon and x is empty.

Definition at line 332 of file ConvexPolygon.cc.

                                                         {
    return (relate(r) & DISJOINT) != 0;
}

isEmpty()

bool lsst::sphgeom::ConvexPolygon::isEmpty ( ) const

overridevirtual

isEmpty returns true when a region does not contain any points.

Implements lsst::sphgeom::Region.

Definition at line 303 of file ConvexPolygon.cc.

                                  {
    // Polygons should not be empty by construction.
    return true;
}

isWithin()

bool lsst::sphgeom::ConvexPolygon::isWithin

(

Region const &

r

)

const

isWithin returns true if the intersection of this convex polygon and x is this convex polygon.

Definition at line 340 of file ConvexPolygon.cc.

                                                   {
    return (relate(r) & WITHIN) != 0;
}

operator!=()

bool lsst::sphgeom::ConvexPolygon::operator!= ( ConvexPolygon const & p ) const

inline

Definition at line 105 of file ConvexPolygon.h.

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

operator==()

bool lsst::sphgeom::ConvexPolygon::operator==

(

ConvexPolygon const &

p

)

const

Two convex polygons are equal iff they contain the same points.

Definition at line 268 of file ConvexPolygon.cc.

                                                            {
    if (this == &p) {
        return true;
    }
    if (_vertices.size() != p._vertices.size()) {
        return false;
    }
    VertexIterator i = _vertices.begin();
    VertexIterator f = p._vertices.begin();
    VertexIterator const ep = p._vertices.end();
    // Find vertex f of p equal to the first vertex of this polygon.
    for (; f != ep; ++f) {
        if (*i == *f) {
            break;
        }
    }
    if (f == ep) {
        // No vertex of p is equal to the first vertex of this polygon.
        return false;
    }
    // Now, compare all vertices.
    ++i;
    for (VertexIterator j = f + 1; j != ep; ++i, ++j) {
        if (*i != *j) {
            return false;
        }
    }
    for (VertexIterator j = p._vertices.begin(); j != f; ++i, ++j) {
        if (*i != *j) {
            return false;
        }
    }
    return true;
}

overlaps() [1/5]

TriState lsst::sphgeom::ConvexPolygon::overlaps ( Box const & ) const

overridevirtual

overlaps tests whether two regions overlap. This method returns a TriState object, when the value is true it means that regions definitely overlap, false means they are definitely disjont, and unknown state means that they may or may not overlap.

Implements lsst::sphgeom::Region.

Definition at line 360 of file ConvexPolygon.cc.

                                                   {
    // Relation with box uses approximations, we cannot know exact answer.
    return _relationship_to_overlaps(relate(b));
}

overlaps() [2/5]

TriState lsst::sphgeom::ConvexPolygon::overlaps ( Circle const & ) const

overridevirtual

overlaps tests whether two regions overlap. This method returns a TriState object, when the value is true it means that regions definitely overlap, false means they are definitely disjont, and unknown state means that they may or may not overlap.

Implements lsst::sphgeom::Region.

Definition at line 365 of file ConvexPolygon.cc.

                                                      {
    // Circle relation is exact, not-disjoint means they overlap.
    return TriState((relate(c) & DISJOINT) == 0);
}

overlaps() [3/5]

TriState lsst::sphgeom::ConvexPolygon::overlaps ( ConvexPolygon const & ) const

overridevirtual

overlaps tests whether two regions overlap. This method returns a TriState object, when the value is true it means that regions definitely overlap, false means they are definitely disjont, and unknown state means that they may or may not overlap.

Implements lsst::sphgeom::Region.

Definition at line 370 of file ConvexPolygon.cc.

                                                             {
    // Polygon relation is exact, not-disjoint means they overlap.
    return TriState((relate(p) & DISJOINT) == 0);
}

overlaps() [4/5]

TriState lsst::sphgeom::ConvexPolygon::overlaps ( Ellipse const & ) const

overridevirtual

overlaps tests whether two regions overlap. This method returns a TriState object, when the value is true it means that regions definitely overlap, false means they are definitely disjont, and unknown state means that they may or may not overlap.

Implements lsst::sphgeom::Region.

Definition at line 375 of file ConvexPolygon.cc.

                                                       {
    // Relation with ellipse uses approximations, we cannot know exact answer.
    return _relationship_to_overlaps(relate(e));
}

overlaps() [5/5]

TriState lsst::sphgeom::ConvexPolygon::overlaps ( Region const & other ) const

inlineoverridevirtual

overlaps tests whether two regions overlap. This method returns a TriState object, when the value is true it means that regions definitely overlap, false means they are definitely disjont, and unknown state means that they may or may not overlap.

Implements lsst::sphgeom::Region.

Definition at line 163 of file ConvexPolygon.h.

                                                          {
        return other.overlaps(*this);
    }

relate() [1/5]

Relationship lsst::sphgeom::ConvexPolygon::relate ( Box const & ) const

overridevirtual

relate computes the spatial relationships between this region A and another region B. The return value S is a bitset with the following properties:

• Bit S & DISJOINT is set only if A and B do not have any points in common.
• Bit S & CONTAINS is set only if A contains all points in B.
• Bit S & WITHIN is set only if B contains all points in A.

Said another way: if the CONTAINS, WITHIN or DISJOINT bit is set, then the corresponding spatial relationship between the two regions holds conclusively. If it is not set, the relationship may or may not hold.

These semantics allow for conservative relationship computations. In particular, a Region may choose to implement relate by replacing itself and/or the argument with a simplified bounding region.

Implements lsst::sphgeom::Region.

Definition at line 344 of file ConvexPolygon.cc.

                                                      {
    return detail::relate(_vertices.begin(), _vertices.end(), b);
}

relate() [2/5]

Relationship lsst::sphgeom::ConvexPolygon::relate ( Circle const & ) const

overridevirtual

relate computes the spatial relationships between this region A and another region B. The return value S is a bitset with the following properties:

• Bit S & DISJOINT is set only if A and B do not have any points in common.
• Bit S & CONTAINS is set only if A contains all points in B.
• Bit S & WITHIN is set only if B contains all points in A.

Said another way: if the CONTAINS, WITHIN or DISJOINT bit is set, then the corresponding spatial relationship between the two regions holds conclusively. If it is not set, the relationship may or may not hold.

These semantics allow for conservative relationship computations. In particular, a Region may choose to implement relate by replacing itself and/or the argument with a simplified bounding region.

Implements lsst::sphgeom::Region.

Definition at line 348 of file ConvexPolygon.cc.

                                                         {
    return detail::relate(_vertices.begin(), _vertices.end(), c);
}

relate() [3/5]

Relationship lsst::sphgeom::ConvexPolygon::relate ( ConvexPolygon const & ) const

overridevirtual

relate computes the spatial relationships between this region A and another region B. The return value S is a bitset with the following properties:

• Bit S & DISJOINT is set only if A and B do not have any points in common.
• Bit S & CONTAINS is set only if A contains all points in B.
• Bit S & WITHIN is set only if B contains all points in A.

Said another way: if the CONTAINS, WITHIN or DISJOINT bit is set, then the corresponding spatial relationship between the two regions holds conclusively. If it is not set, the relationship may or may not hold.

These semantics allow for conservative relationship computations. In particular, a Region may choose to implement relate by replacing itself and/or the argument with a simplified bounding region.

Implements lsst::sphgeom::Region.

Definition at line 352 of file ConvexPolygon.cc.

                                                                {
    return detail::relate(_vertices.begin(), _vertices.end(), p);
}

relate() [4/5]

Relationship lsst::sphgeom::ConvexPolygon::relate ( Ellipse const & ) const

overridevirtual

relate computes the spatial relationships between this region A and another region B. The return value S is a bitset with the following properties:

• Bit S & DISJOINT is set only if A and B do not have any points in common.
• Bit S & CONTAINS is set only if A contains all points in B.
• Bit S & WITHIN is set only if B contains all points in A.

Said another way: if the CONTAINS, WITHIN or DISJOINT bit is set, then the corresponding spatial relationship between the two regions holds conclusively. If it is not set, the relationship may or may not hold.

These semantics allow for conservative relationship computations. In particular, a Region may choose to implement relate by replacing itself and/or the argument with a simplified bounding region.

Implements lsst::sphgeom::Region.

Definition at line 356 of file ConvexPolygon.cc.

                                                          {
    return detail::relate(_vertices.begin(), _vertices.end(), e);
}

relate() [5/5]

Relationship lsst::sphgeom::ConvexPolygon::relate ( Region const & ) const

inlineoverridevirtual

relate computes the spatial relationships between this region A and another region B. The return value S is a bitset with the following properties:

• Bit S & DISJOINT is set only if A and B do not have any points in common.
• Bit S & CONTAINS is set only if A contains all points in B.
• Bit S & WITHIN is set only if B contains all points in A.

Said another way: if the CONTAINS, WITHIN or DISJOINT bit is set, then the corresponding spatial relationship between the two regions holds conclusively. If it is not set, the relationship may or may not hold.

These semantics allow for conservative relationship computations. In particular, a Region may choose to implement relate by replacing itself and/or the argument with a simplified bounding region.

Implements lsst::sphgeom::Region.

Definition at line 153 of file ConvexPolygon.h.

                                                         {
        // Dispatch on the type of r.
        return invert(r.relate(*this));
    }

Member Data Documentation

TYPE_CODE

constexpr std::uint8_t lsst::sphgeom::ConvexPolygon::TYPE_CODE = 'p'

staticconstexpr

Definition at line 67 of file ConvexPolygon.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/sphgeom/g3e8969e208+a8ce1bb630/include/lsst/sphgeom/ConvexPolygon.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/sphgeom/g3e8969e208+a8ce1bb630/src/ConvexPolygon.cc