lsst::geom::IntervalD Class Reference

A floating-point coordinate rectangle geometry. More...

#include <Interval.h>

Public Types
using	Element = double

Public Member Functions
	IntervalD () noexcept
	Construct an empty interval.
	IntervalD (IntervalI const &other) noexcept
	Construct a floating-point interval from an integer interval.
	IntervalD (IntervalD const &) noexcept=default
	Standard copy constructor.
	IntervalD (IntervalD &&) noexcept=default
	Standard move constructor.
	~IntervalD () noexcept=default
void	swap (IntervalD &other) noexcept
IntervalD &	operator= (IntervalD const &) noexcept=default
	Standard copy assignment operator.
IntervalD &	operator= (IntervalD &&) noexcept=default
	Standard move assignment operator.

Static Public Member Functions
template<typename Iter >
static IntervalD	fromSpannedPoints (Iter first, Iter last)
	Construct an interval that contains all of the given points.
static IntervalD	fromSpannedPoints (std::vector< Element > const &elements)
	Construct an interval that contains all of the given points.
static IntervalD	fromSpannedPoints (ndarray::Array< Element const, 1 > const &elements)
static IntervalD	fromMinMax (Element min, Element max)
	Construct an interval from its lower and upper bounds.
static IntervalD	fromMinSize (Element min, Element size)
	Construct an interval from its lower bound and size.
static IntervalD	fromMaxSize (Element max, Element size)
	Construct an interval from its upper bound and size.
static IntervalD	fromCenterSize (double center, Element size)
	Construct an interval centered on a particular point.

Min/Max Accessors
Return the minimum (inclusive) and maximum (exclusive) coordinates of the interval.
Element	getMin () const noexcept
	Return the size of the interval.
Element	getMax () const noexcept
	Return the size of the interval.
Element	getSize () const noexcept
	Return the size of the interval.
Element	getCenter () const noexcept
	Return the center coordinate of the interval.
bool	isEmpty () const noexcept
	Return true if the interval contains no points.
bool	isFinite () const noexcept
	Return true if the interval's size is finite.
bool	contains (Element point) const
	Return true if the interval contains the point.
bool	contains (IntervalD const &other) const noexcept
	Return true if all points contained by other are also contained by this.
bool	overlaps (IntervalD const &other) const noexcept
	Return true if any points in other are also in this.
bool	intersects (IntervalD const &other) const noexcept
	Return the size of the interval.
bool	isDisjointFrom (IntervalD const &other) const noexcept
	Return true if there are no points in both this and other.
IntervalD	dilatedBy (Element buffer) const
	Increase the size of the interval by the given amount in both directions (returning a new object).
IntervalD	erodedBy (Element buffer) const
	Decrease the size of the interval by the given amount in both directions (returning a new object).
IntervalD	shiftedBy (Element offset) const
	Shift the position of the interval by the given offset (returning a new object).
IntervalD	reflectedAbout (Element point) const
	Reflect an interval about a point (returning a new object).
IntervalD	expandedTo (Element other) const
	Expand an interval to ensure that contains(other) is true.
IntervalD	expandedTo (IntervalD const &other) const noexcept
	Expand an interval to ensure that contains(other) is true.
IntervalD	clippedTo (IntervalD const &other) const noexcept
	Shrink an interval to ensure that it is contained by other (returning a new object).
bool	operator== (IntervalD const &other) const noexcept
	Compare two intervals for equality.
bool	operator!= (IntervalD const &other) const noexcept
	Compare two intervals for equality.
std::size_t	hash_value () const noexcept
	Return a hash of this object.
std::string	toString () const
	Return the size of the interval.

Detailed Description

A floating-point coordinate rectangle geometry.

IntervalD is closed (its bounds are considered included in the interval). An interval never has negative size; the empty interval is defined to zero-size size and its minimum and maximum values are set to NaN. Non-empty intervals representing infinitesimal points may also have zero size, but are not considered empty.

The existence of zero-size, non-empty intervals is an important, intentional difference between IntervalI and IntervalD, related to the fact that IntervalI models a discrete set while IntervalD (imperfectly, due to floating-point limitations) models a continuous set.

Definition at line 413 of file Interval.h.

Member Typedef Documentation

Element

using lsst::geom::IntervalD::Element = double

Definition at line 415 of file Interval.h.

Constructor & Destructor Documentation

IntervalD() [1/4]

lsst::geom::IntervalD::IntervalD ( )

noexcept

Construct an empty interval.

Definition at line 222 of file Interval.cc.

        : _min(std::numeric_limits<IntervalD::Element>::quiet_NaN()),
          _max(std::numeric_limits<IntervalD::Element>::quiet_NaN()) {}

IntervalD() [2/4]

lsst::geom::IntervalD::IntervalD ( IntervalI const & other )

explicitnoexcept

Construct a floating-point interval from an integer interval.

Integer to floating-point interval conversion is based on the concept that a pixel is not an infinitesimal point but rather a square of unit size centered on integer-valued coordinates. While the output floating-point interval thus has the same size as the input integer interval, its minimum/maximum coordinates are 0.5 smaller/greater.

Definition at line 254 of file Interval.cc.

        : _min(other.getMin() - 0.5), _max(other.getMax() + 0.5) {
    if (other.isEmpty()) *this = IntervalD();
}

IntervalD() [3/4]

lsst::geom::IntervalD::IntervalD ( IntervalD const & )

defaultnoexcept

Standard copy constructor.

IntervalD() [4/4]

lsst::geom::IntervalD::IntervalD ( IntervalD && )

defaultnoexcept

Standard move constructor.

~IntervalD()

lsst::geom::IntervalD::~IntervalD ( )

defaultnoexcept

Member Function Documentation

clippedTo()

IntervalD lsst::geom::IntervalD::clippedTo ( IntervalD const & other ) const

noexcept

Shrink an interval to ensure that it is contained by other (returning a new object).

In particular, if other and this interval do not overlap the new interval will be empty.

Definition at line 335 of file Interval.cc.

                                                                    {
    if (this->isEmpty() || other.isEmpty()) {
        return IntervalD();
    } else {
        return fromMinMax(std::max(this->getMin(), other.getMin()), std::min(this->getMax(), other.getMax()));
    }
}

contains() [1/2]

bool lsst::geom::IntervalD::contains

(

Element

point

)

const

Return true if the interval contains the point.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if point is NaN.

Definition at line 263 of file Interval.cc.

                                            {
    if (std::isnan(point)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Cannot test whether an interval contains NaN.");
    }
    return point >= this->getMin() && point <= this->getMax();
}

contains() [2/2]

bool lsst::geom::IntervalD::contains ( IntervalD const & other ) const

noexcept

Return true if all points contained by other are also contained by this.

An empty interval is contained by every other interval, including other empty intervals.

Definition at line 271 of file Interval.cc.

                                                              {
    return other.isEmpty() || (other.getMin() >= this->getMin() && other.getMax() <= this->getMax());
}

dilatedBy()

IntervalD lsst::geom::IntervalD::dilatedBy

(

Element

buffer

)

const

Increase the size of the interval by the given amount in both directions (returning a new object).

If buffer is negative, this is equivalent to eroding by -buffer.

If the final size of the interval is less than zero, the new interval will be empty.

Empty intervals remain empty after dilation. Infinite bounds are unaffected by dilation.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if buffer is not finite.

Definition at line 284 of file Interval.cc.

                                                   {
    if (!std::isfinite(buffer)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Cannot dilate or erode with a non-finite buffer.");
    }
    return fromMinMax(_min - buffer, _max + buffer);
}

erodedBy()

IntervalD lsst::geom::IntervalD::erodedBy ( Element buffer ) const

inline

Decrease the size of the interval by the given amount in both directions (returning a new object).

If buffer is negative, this is equivalent to dilating by -buffer.

If the final size of the interval is less than zero, the new interval will be empty.

Empty intervals remain empty after erosion. Infinite bounds are unaffected by erosion.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if buffer is not finite.

Definition at line 648 of file Interval.h.

{ return dilatedBy(-buffer); }

expandedTo() [1/2]

IntervalD lsst::geom::IntervalD::expandedTo

(

Element

other

)

const

Expand an interval to ensure that contains(other) is true.

Expanding an empty interval with a single point yields an interval with size == 0 at that point.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if other is not finite.

Definition at line 314 of file Interval.cc.

                                                   {
    if (!std::isfinite(point)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Cannot expand to a non-finite point.");
    }
    if (isEmpty()) {
        return fromMinMax(point, point);
    } else {
        return fromMinMax(std::min(point, _min), std::max(point, _max));
    }
}

expandedTo() [2/2]

IntervalD lsst::geom::IntervalD::expandedTo ( IntervalD const & other ) const

noexcept

Expand an interval to ensure that contains(other) is true.

Expanding an empty interval with a second interval is equivalent to assignment.

Expanding by an empty interval yields the original interval.

Definition at line 325 of file Interval.cc.

                                                                     {
    if (other.isEmpty()) {
        return *this;
    } else if (this->isEmpty()) {
        return other;
    } else {
        return fromMinMax(std::min(this->getMin(), other.getMin()), std::max(this->getMax(), other.getMax()));
    }
}

fromCenterSize()

IntervalD lsst::geom::IntervalD::fromCenterSize ( double center, Element size )

static

Construct an interval centered on a particular point.

Parameters

center	The desired center of the interval. May not be infinite.
size	Number of pixels in interval. May not be infinite.

If size < 0 or any parameter is NaN, an empty interval is returned.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if any parameter is infinite. This includes the case where one parameter is NaN and the other is infinite.

Definition at line 246 of file Interval.cc.

                                                                {
    if (std::isinf(center) || std::isinf(size)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Infinite values not supported.");
    }
    Element min = center - 0.5 * size;
    return lsst::geom::IntervalD::fromMinSize(min, size);
}

fromMaxSize()

IntervalD lsst::geom::IntervalD::fromMaxSize ( Element max, Element size )

static

Construct an interval from its upper bound and size.

Parameters

[in]	max	Maximum coordinate (inclusive).
[in]	size	Size of interval.

If size < 0 or any parameter is NaN, an empty interval is returned.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if min is infinite or if size is +infinity (-infinity yields an empty interval).

Definition at line 237 of file Interval.cc.

                                                          {
    if (std::isinf(max) || (std::isinf(size) && size > 0)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Ambiguously infinite interval parameters; use fromMinMax to "
                          "construct infinite intervals instead.");
    }
    return IntervalD(max - size, max);
}

fromMinMax()

IntervalD lsst::geom::IntervalD::fromMinMax ( Element min, Element max )

static

Construct an interval from its lower and upper bounds.

Parameters

[in]	min	Minimum coordinate (inclusive).
[in]	max	Maximum coordinate (inclusive).

Bounds may be non-finite, with some restrictions.

• If min is -inf and/or max is +inf, the interval has infinite size and is considered valid.
• If max < min (regardless of whether one or both is infinite) or either is NaN, the interval is empty.
• min == max == +inf or min == max == -inf is an error.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if min == max == inf or min == max == -inf.

Definition at line 226 of file Interval.cc.

{ return IntervalD(min, max); }

fromMinSize()

IntervalD lsst::geom::IntervalD::fromMinSize ( Element min, Element size )

static

Construct an interval from its lower bound and size.

Parameters

[in]	min	Minimum coordinate (inclusive).
[in]	size	Size of interval.

If size < 0 or any parameter is NaN, an empty interval is returned.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if min is infinite or if size is +infinity (-infinity yields an empty interval).

Definition at line 228 of file Interval.cc.

                                                          {
    if (std::isinf(min) || (std::isinf(size) && size > 0)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Ambiguously infinite interval parameters; use fromMinMax to "
                          "construct infinite intervals instead.");
    }
    return IntervalD(min, min + size);
}

fromSpannedPoints() [1/3]

template<typename Iter >

static IntervalD lsst::geom::IntervalD::fromSpannedPoints ( Iter first, Iter last )

inlinestatic

Construct an interval that contains all of the given points.

Parameters

[in]	first	Iterator to the beginning of a sequence of floating-point values.
[in]	last	Iterator to one-past-the-end of a sequence of floating-point values.

An empty interval is returned if first == last.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if any input point is non-finite.

Definition at line 434 of file Interval.h.

                                                              {
        IntervalD result;
        for (auto i = first; i != last; ++i) {
            result = result.expandedTo(*i);
        }
        return result;
    }

fromSpannedPoints() [2/3]

static IntervalD lsst::geom::IntervalD::fromSpannedPoints ( ndarray::Array< Element const, 1 > const & elements )

inlinestatic

Definition at line 457 of file Interval.h.

                                                                                       {
        return fromSpannedPoints(elements.begin(), elements.end());
    }

fromSpannedPoints() [3/3]

static IntervalD lsst::geom::IntervalD::fromSpannedPoints ( std::vector< Element > const & elements )

inlinestatic

Construct an interval that contains all of the given points.

Parameters

[in]

elements

Points (floating-point values) to include in the interval.

An empty interval is returned if the given container has no elements.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if any input point is non-finite.

Definition at line 454 of file Interval.h.

                                                                           {
        return fromSpannedPoints(elements.begin(), elements.end());
    }

getCenter()

IntervalD::Element lsst::geom::IntervalD::getCenter ( ) const

noexcept

Return the center coordinate of the interval.

Returns NaN for empty intervals and infinite intervals.

Definition at line 261 of file Interval.cc.

{ return 0.5 * (_min + _max); }

getMax()

Element lsst::geom::IntervalD::getMax ( ) const

inlinenoexcept

Return the size of the interval.

Empty intervals have zero size, but not all zero-size intervals are empty. Intervals with an infinite bound have infinite size.

Definition at line 560 of file Interval.h.

{ return _max; }

getMin()

Element lsst::geom::IntervalD::getMin ( ) const

inlinenoexcept

Return the size of the interval.

Empty intervals have zero size, but not all zero-size intervals are empty. Intervals with an infinite bound have infinite size.

Definition at line 559 of file Interval.h.

{ return _min; }

getSize()

IntervalD::Element lsst::geom::IntervalD::getSize ( ) const

noexcept

Return the size of the interval.

Empty intervals have zero size, but not all zero-size intervals are empty. Intervals with an infinite bound have infinite size.

Definition at line 259 of file Interval.cc.

{ return isEmpty() ? 0.0 : (_max - _min); }

hash_value()

std::size_t lsst::geom::IntervalD::hash_value ( ) const

noexcept

Return a hash of this object.

Definition at line 349 of file Interval.cc.

                                               {
    // Completely arbitrary seed
    return cpputils::hashCombine(17, _min, _max);
}

intersects()

bool lsst::geom::IntervalD::intersects ( IntervalD const & other ) const

inlinenoexcept

Return the size of the interval.

Empty intervals have zero size, but not all zero-size intervals are empty. Intervals with an infinite bound have infinite size.

Definition at line 608 of file Interval.h.

{ return overlaps(other); }

isDisjointFrom()

bool lsst::geom::IntervalD::isDisjointFrom ( IntervalD const & other ) const

noexcept

Return true if there are no points in both this and other.

Definition at line 277 of file Interval.cc.

                                                                    {
    if (isEmpty() || other.isEmpty()) {
        return true;
    }
    return getMin() > other.getMax() || getMax() < other.getMin();
}

isEmpty()

bool lsst::geom::IntervalD::isEmpty ( ) const

inlinenoexcept

Return true if the interval contains no points.

Definition at line 579 of file Interval.h.

{ return std::isnan(_min); }

isFinite()

bool lsst::geom::IntervalD::isFinite ( ) const

inlinenoexcept

Return true if the interval's size is finite.

Definition at line 582 of file Interval.h.

{ return std::isfinite(getSize()); }

operator!=()

bool lsst::geom::IntervalD::operator!= ( IntervalD const & other ) const

noexcept

Compare two intervals for equality.

All empty intervals are equal.

Definition at line 347 of file Interval.cc.

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

operator=() [1/2]

IntervalD & lsst::geom::IntervalD::operator= ( IntervalD && )

defaultnoexcept

Standard move assignment operator.

operator=() [2/2]

IntervalD & lsst::geom::IntervalD::operator= ( IntervalD const & )

defaultnoexcept

Standard copy assignment operator.

operator==()

bool lsst::geom::IntervalD::operator== ( IntervalD const & other ) const

noexcept

Compare two intervals for equality.

All empty intervals are equal.

Definition at line 343 of file Interval.cc.

                                                                {
    return (other.isEmpty() && this->isEmpty()) || (other._min == this->_min && other._max == this->_max);
}

overlaps()

bool lsst::geom::IntervalD::overlaps ( IntervalD const & other ) const

noexcept

Return true if any points in other are also in this.

Any overlap operation involving an empty interval returns false.

Definition at line 275 of file Interval.cc.

{ return !isDisjointFrom(other); }

reflectedAbout()

IntervalD lsst::geom::IntervalD::reflectedAbout

(

Element

point

)

const

Reflect an interval about a point (returning a new object).

Empty intervals remain empty when reflected. If an interval with an infinite bound is reflected, the opposite bound will become infinite with the opposite sign.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if point is not finite.

Definition at line 303 of file Interval.cc.

                                                       {
    if (!std::isfinite(point)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Cannot reflect about a non-finite point.");
    }
    if (!isEmpty()) {
        return fromMinMax(2 * point - _max, 2 * point - _min);
    } else {
        return IntervalD();
    }
}

shiftedBy()

IntervalD lsst::geom::IntervalD::shiftedBy

(

Element

offset

)

const

Shift the position of the interval by the given offset (returning a new object).

Empty intervals remain empty when shifted. Infinite bounds are unaffected by shifting.

Exceptions

lsst::pex::exceptions::InvalidParameterError

Thrown if offset is not finite.

Definition at line 292 of file Interval.cc.

                                                   {
    if (!std::isfinite(offset)) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Cannot shift with a non-finite offset.");
    }
    if (!isEmpty()) {
        return fromMinMax(_min + offset, _max + offset);
    } else {
        return IntervalD();
    }
}

swap()

void lsst::geom::IntervalD::swap ( IntervalD & other )

inlinenoexcept

Definition at line 541 of file Interval.h.

                                         {
        std::swap(_min, other._min);
        std::swap(_max, other._max);
    }

toString()

std::string lsst::geom::IntervalD::toString

(

)

const

Return the size of the interval.

Empty intervals have zero size, but not all zero-size intervals are empty. Intervals with an infinite bound have infinite size.

Definition at line 354 of file Interval.cc.

                                    {
    return (boost::format("(min=%s, max=%s)") % getMin() % getMax()).str();
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/geom/g414038480c+077ccc18e7/include/lsst/geom/Interval.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/geom/g414038480c+077ccc18e7/src/Interval.cc