lsst::sphgeom::CompoundRegion Class Reference

CompoundRegion is an intermediate base class for spherical regions that are comprised of a point-set operation on other nested regions. More...

#include <CompoundRegion.h>

Inheritance diagram for lsst::sphgeom::CompoundRegion:

Public Member Functions
	CompoundRegion (Region const &first, Region const &second)
	Construct by copying or taking ownership of operands.
	CompoundRegion (std::array< std::unique_ptr< Region >, 2 > operands) noexcept
	CompoundRegion (CompoundRegion const &)
	CompoundRegion (CompoundRegion &&) noexcept=default
CompoundRegion &	operator= (CompoundRegion const &)=delete
CompoundRegion &	operator= (CompoundRegion &&)=delete
Region const &	getOperand (std::size_t n) const
virtual Relationship	relate (Region const &r) const =0
Relationship	relate (Box const &b) const override
Relationship	relate (Circle const &c) const override
Relationship	relate (ConvexPolygon const &p) const override
Relationship	relate (Ellipse const &e) const override
virtual std::unique_ptr< Region >	clone () const =0
	clone returns a deep copy of this region.
virtual Box	getBoundingBox () const =0
	getBoundingBox returns a bounding-box for this region.
virtual Box3d	getBoundingBox3d () const =0
	getBoundingBox3d returns a 3-dimensional bounding-box for this region.
virtual Circle	getBoundingCircle () const =0
	getBoundingCircle returns a bounding-circle for this region.
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.
virtual std::vector< std::uint8_t >	encode () const =0
	encode serializes this region into an opaque byte string.

Static Public Member Functions
static std::vector< std::unique_ptr< Region > >	getRegions (Region const &region)
	getRegions returns a vector of Region.
static std::unique_ptr< CompoundRegion >	decode (std::vector< std::uint8_t > const &s)
static std::unique_ptr< CompoundRegion >	decode (std::uint8_t const *buffer, size_t n)

Protected Member Functions
std::vector< std::uint8_t >	_encode (std::uint8_t tc) const

Static Protected Member Functions
static std::array< std::unique_ptr< Region >, 2 >	_decode (std::uint8_t tc, std::uint8_t const *buffer, std::size_t nBytes)

Detailed Description

CompoundRegion is an intermediate base class for spherical regions that are comprised of a point-set operation on other nested regions.

Definition at line 55 of file CompoundRegion.h.

Constructor & Destructor Documentation

CompoundRegion() [1/4]

lsst::sphgeom::CompoundRegion::CompoundRegion	(	Region const &	first,
		Region const &	second )

Construct by copying or taking ownership of operands.

Definition at line 77 of file CompoundRegion.cc.

        : _operands{first.clone(), second.clone()} {}

CompoundRegion() [2/4]

lsst::sphgeom::CompoundRegion::CompoundRegion ( std::array< std::unique_ptr< Region >, 2 > operands )

explicitnoexcept

Definition at line 80 of file CompoundRegion.cc.

        : _operands(std::move(operands)) {}

CompoundRegion() [3/4]

lsst::sphgeom::CompoundRegion::CompoundRegion

(

CompoundRegion const &

other

)

Definition at line 84 of file CompoundRegion.cc.

        : _operands{other.getOperand(0).clone(), other.getOperand(1).clone()} {}

CompoundRegion() [4/4]

lsst::sphgeom::CompoundRegion::CompoundRegion ( CompoundRegion && )

defaultnoexcept

Member Function Documentation

_decode()

std::array< std::unique_ptr< Region >, 2 > lsst::sphgeom::CompoundRegion::_decode ( std::uint8_t tc, std::uint8_t const * buffer, std::size_t nBytes )

staticprotected

Definition at line 104 of file CompoundRegion.cc.

                                                               {
    std::uint8_t const *end = buffer + nBytes;
    if (nBytes == 0) {
        throw std::runtime_error("Encoded CompoundRegion is truncated.");
    }
    if (buffer[0] != tc) {
        throw std::runtime_error("Byte string is not an encoded CompoundRegion.");
    }
    ++buffer;
    std::array<std::unique_ptr<Region>, 2> result;
    std::uint64_t nBytes1 = consumeDecodeU64(buffer, end);
    result[0] = Region::decode(buffer, nBytes1);
    buffer += nBytes1;
    std::uint64_t nBytes2 = consumeDecodeU64(buffer, end);
    result[1] = Region::decode(buffer, nBytes2);
    buffer += nBytes2;
    if (buffer != end) {
        throw std::runtime_error("Encoded CompoundRegion is has unexpected additional bytes.");
    }
    return result;
}

_encode()

std::vector< std::uint8_t > lsst::sphgeom::CompoundRegion::_encode ( std::uint8_t tc ) const

protected

Definition at line 92 of file CompoundRegion.cc.

                                                                 {
    std::vector<std::uint8_t> buffer;
    buffer.push_back(tc);
    auto buffer1 = getOperand(0).encode();
    encodeU64(buffer1.size(), buffer);
    buffer.insert(buffer.end(), buffer1.begin(), buffer1.end());
    auto buffer2 = getOperand(1).encode();
    encodeU64(buffer2.size(), buffer);
    buffer.insert(buffer.end(), buffer2.begin(), buffer2.end());
    return buffer;
}

clone()

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

pure virtualinherited

clone returns a deep copy of this region.

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

contains() [1/3]

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

inherited

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

Definition at line 51 of file Region.cc.

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

contains() [2/3]

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

inherited

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

Definition at line 47 of file Region.cc.

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

contains() [3/3]

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

pure virtualinherited

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

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, lsst::sphgeom::Ellipse, lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

decode() [1/2]

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

static

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

Definition at line 127 of file CompoundRegion.cc.

                                                                                       {
    if (n == 0) {
        throw std::runtime_error("Encoded CompoundRegion is truncated.");
    }
    switch (buffer[0]) {
        case UnionRegion::TYPE_CODE:
            return UnionRegion::decode(buffer, n);
        case IntersectionRegion::TYPE_CODE:
            return IntersectionRegion::decode(buffer, n);
        default:
            throw std::runtime_error("Byte string is not an encoded CompoundRegion.");
    }
}

decode() [2/2]

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

inlinestatic

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

Definition at line 86 of file CompoundRegion.h.

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

encode()

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

pure virtualinherited

encode serializes this region into an opaque byte string.

Byte strings emitted by encode can be deserialized with decode.

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

getBoundingBox()

virtual Box lsst::sphgeom::Region::getBoundingBox ( ) const

pure virtualinherited

getBoundingBox returns a bounding-box for this region.

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

getBoundingBox3d()

virtual Box3d lsst::sphgeom::Region::getBoundingBox3d ( ) const

pure virtualinherited

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

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

getBoundingCircle()

virtual Circle lsst::sphgeom::Region::getBoundingCircle ( ) const

pure virtualinherited

getBoundingCircle returns a bounding-circle for this region.

Implemented in lsst::sphgeom::Box, lsst::sphgeom::Circle, lsst::sphgeom::UnionRegion, lsst::sphgeom::IntersectionRegion, lsst::sphgeom::ConvexPolygon, and lsst::sphgeom::Ellipse.

getOperand()

Region const & lsst::sphgeom::CompoundRegion::getOperand ( std::size_t n ) const

inline

Definition at line 72 of file CompoundRegion.h.

                                                 {
        return *_operands[n];
    }

getRegions()

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

staticinherited

getRegions returns a vector of Region.

Definition at line 76 of file Region.cc.

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

operator=() [1/2]

CompoundRegion & lsst::sphgeom::CompoundRegion::operator= ( CompoundRegion && )

delete

operator=() [2/2]

CompoundRegion & lsst::sphgeom::CompoundRegion::operator= ( CompoundRegion const & )

delete

relate() [1/5]

Relationship lsst::sphgeom::CompoundRegion::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 87 of file CompoundRegion.cc.

{ return relate(static_cast<Region const &>(b)); }

relate() [2/5]

Relationship lsst::sphgeom::CompoundRegion::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 88 of file CompoundRegion.cc.

{ return relate(static_cast<Region const &>(c)); }

relate() [3/5]

Relationship lsst::sphgeom::CompoundRegion::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 89 of file CompoundRegion.cc.

{ return relate(static_cast<Region const &>(p)); }

relate() [4/5]

Relationship lsst::sphgeom::CompoundRegion::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 90 of file CompoundRegion.cc.

{ return relate(static_cast<Region const &>(e)); }

relate() [5/5]

virtual Relationship lsst::sphgeom::CompoundRegion::relate ( Region const & ) const

pure virtual

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.

Implemented in lsst::sphgeom::UnionRegion, and lsst::sphgeom::IntersectionRegion.

---

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

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