lsst::sphgeom::IntersectionRegion Class Reference

IntersectionRegion is a lazy point-set inersection of its operands. More...

#include <CompoundRegion.h>

Inheritance diagram for lsst::sphgeom::IntersectionRegion:

Public Member Functions
std::unique_ptr< Region >	clone () const override
	clone returns a deep copy of this region.
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.
bool	contains (UnitVector3d const &v) const override
	contains tests whether the given unit vector is inside this region.
Relationship	relate (Region const &r) const override
std::vector< std::uint8_t >	encode () const override
	encode serializes this region into an opaque byte string.
	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
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.
Region const &	getOperand (std::size_t n) const
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

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< IntersectionRegion >	decode (std::vector< std::uint8_t > const &s)
static std::unique_ptr< IntersectionRegion >	decode (std::uint8_t const *buffer, size_t n)

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

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

IntersectionRegion is a lazy point-set inersection of its operands.

All operations on a IntersectionRegion are implementing by delegating to its nested operand regions and combining the results.

Definition at line 142 of file CompoundRegion.h.

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 )

staticprotectedinherited

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

protectedinherited

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

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

inlineoverridevirtual

clone returns a deep copy of this region.

Implements lsst::sphgeom::Region.

Definition at line 149 of file CompoundRegion.h.

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

CompoundRegion() [1/4]

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

defaultnoexcept

CompoundRegion() [2/4]

lsst::sphgeom::CompoundRegion::CompoundRegion

(

CompoundRegion const &

other

)

Definition at line 63 of file CompoundRegion.cc.

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

CompoundRegion() [3/4]

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

Construct by copying or taking ownership of operands.

Definition at line 59 of file CompoundRegion.cc.

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

CompoundRegion() [4/4]

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

explicitnoexcept

Definition at line 60 of file CompoundRegion.cc.

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

contains() [1/4]

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 112 of file Region.cc.

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

contains() [2/4]

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 108 of file Region.cc.

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

contains() [3/4]

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() [4/4]

bool lsst::sphgeom::IntersectionRegion::contains ( UnitVector3d const & ) const

overridevirtual

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

Implements lsst::sphgeom::Region.

Definition at line 183 of file CompoundRegion.cc.

                                                             {
    return getOperand(0).contains(v) && getOperand(1).contains(v);
}

decode() [1/2]

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

inlinestatic

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

Definition at line 164 of file CompoundRegion.h.

                                                                                        {
        return std::make_unique<IntersectionRegion>(_decode(TYPE_CODE, buffer, n));
    }

decode() [2/2]

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

inlinestatic

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

Definition at line 161 of file CompoundRegion.h.

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

encode()

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

inlineoverridevirtual

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 156 of file CompoundRegion.h.

{ return _encode(TYPE_CODE); }

getBoundingBox()

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

overridevirtual

getBoundingBox returns a bounding-box for this region.

Implements lsst::sphgeom::Region.

Definition at line 171 of file CompoundRegion.cc.

                                             {
    return getIntersectionBounds(*this, [](Region const &r) { return r.getBoundingBox(); });
}

getBoundingBox3d()

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

overridevirtual

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

Implements lsst::sphgeom::Region.

Definition at line 175 of file CompoundRegion.cc.

                                                 {
    return getIntersectionBounds(*this, [](Region const &r) { return r.getBoundingBox3d(); });
}

getBoundingCircle()

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

overridevirtual

getBoundingCircle returns a bounding-circle for this region.

Implements lsst::sphgeom::Region.

Definition at line 179 of file CompoundRegion.cc.

                                                   {
    return getIntersectionBounds(*this, [](Region const &r) { return r.getBoundingCircle(); });
}

getOperand()

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

inlineinherited

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;
}

relate() [1/5]

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

overridevirtualinherited

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

overridevirtualinherited

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

overridevirtualinherited

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

overridevirtualinherited

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]

Relationship lsst::sphgeom::IntersectionRegion::relate ( Region 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::CompoundRegion.

Definition at line 187 of file CompoundRegion.cc.

                                                               {
    auto r1 = getOperand(0).relate(rhs);
    auto r2 = getOperand(1).relate(rhs);
    return
        // Both operands must contain the given region for the intersection to
        // contain it.
        ((r1 & CONTAINS) & (r2 & CONTAINS))
        // If either operand is disjoint with the given region, the
        // intersection is disjoint with it.
        | ((r1 & DISJOINT) | (r2 & DISJOINT))
        // If either operand is within the given region, the intersection is
        // within it.
        | ((r1 & WITHIN) | (r2 & WITHIN));
}

Member Data Documentation

TYPE_CODE

constexpr std::uint8_t lsst::sphgeom::IntersectionRegion::TYPE_CODE = 'i'

staticconstexpr

Definition at line 144 of file CompoundRegion.h.

---

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