Box.h

Go to the documentation of this file.

/*
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef LSST_GEOM_BOX_H
#define LSST_GEOM_BOX_H
 
#include <vector>
 
#include "boost/format.hpp"
#include "ndarray.h"
 
#include "lsst/geom/Point.h"
#include "lsst/geom/Extent.h"
#include "lsst/geom/Interval.h"
 
namespace lsst {
namespace geom {
 
class Box2D;
 
class Box2I final {
public:
    typedef Point2I Point;
    typedef Extent2I Extent;
    typedef int Element;
 
    using Interval = IntervalI;
 
    enum EdgeHandlingEnum { EXPAND, SHRINK };
 
    Box2I() noexcept : _minimum(0), _dimensions(0) {}
 
    Box2I(Point2I const& minimum, Point2I const& maximum, bool invert = true);
 
    Box2I(Point2I const& corner, Extent2I const& dimensions, bool invert = true);
 
    Box2I(Interval const & x, Interval const & y) :
        Box2I(Point(x.getMin(), y.getMin()), Point(x.getMax(), y.getMax()), false)
    {}
 
    explicit Box2I(Box2D const& other, EdgeHandlingEnum edgeHandling = EXPAND);
 
    Box2I(Box2I const&) noexcept = default;
    Box2I(Box2I&&) noexcept = default;
    ~Box2I() noexcept = default;
 
    static Box2I makeCenteredBox(Point2D const& center, Extent const& size);
 
    void swap(Box2I& other) noexcept {
        _minimum.swap(other._minimum);
        _dimensions.swap(other._dimensions);
    }
 
    Box2I& operator=(Box2I const&) noexcept = default;
    Box2I& operator=(Box2I&&) noexcept = default;
 
    Point2I const getMin() const noexcept { return _minimum; }
    int getMinX() const noexcept { return _minimum.getX(); }
    int getMinY() const noexcept { return _minimum.getY(); }
 
    Point2I const getMax() const noexcept { return _minimum + _dimensions - Extent2I(1); }
    int getMaxX() const noexcept { return _minimum.getX() + _dimensions.getX() - 1; }
    int getMaxY() const noexcept { return _minimum.getY() + _dimensions.getY() - 1; }
 
    Point2I const getBegin() const noexcept { return _minimum; }
    int getBeginX() const noexcept { return _minimum.getX(); }
    int getBeginY() const noexcept { return _minimum.getY(); }
 
    Point2I const getEnd() const noexcept { return _minimum + _dimensions; }
    int getEndX() const noexcept { return _minimum.getX() + _dimensions.getX(); }
    int getEndY() const noexcept { return _minimum.getY() + _dimensions.getY(); }
 
    Extent2I const getDimensions() const noexcept { return _dimensions; }
    int getWidth() const noexcept { return _dimensions.getX(); }
    int getHeight() const noexcept { return _dimensions.getY(); }
    int getArea() const { return getWidth() * getHeight(); }
 
    Point2D const getCenter() const noexcept;
    double getCenterX() const noexcept { return this->getCenter().getX(); }
    double getCenterY() const noexcept { return this->getCenter().getY(); }
 
 
    Interval getX() const { return Interval::fromMinSize(getMinX(), getWidth()); }
    Interval getY() const { return Interval::fromMinSize(getMinY(), getHeight()); }
 
    ndarray::View<boost::fusion::vector2<ndarray::index::Range, ndarray::index::Range> > getSlices() const;
 
    bool isEmpty() const noexcept { return _dimensions.getX() == 0 && _dimensions.getY() == 0; }
 
 
    bool contains(Point2I const& point) const noexcept;
    bool contains(Element x, Element y) const noexcept { return contains(Point2I(x, y)); }
 
    bool contains(Box2I const& other) const noexcept;
 
 
    bool overlaps(Box2I const& other) const noexcept;
    bool intersects(Box2I const& other) const noexcept { return overlaps(other); }
 
    bool isDisjointFrom(Box2I const & other) const noexcept;
 
    void grow(int buffer) { grow(Extent2I(buffer)); }
 
    void grow(Extent2I const& buffer);
 
    void shift(Extent2I const& offset);
 
    void flipLR(int xExtent);
 
    void flipTB(int yExtent);
 
    void include(Point2I const& point);
 
    void include(Box2I const& other);
 
    void clip(Box2I const& other) noexcept;
 
    Box2I dilatedBy(Extent const & buffer) const;
    Box2I dilatedBy(Element buffer) const {
        return dilatedBy(Extent(buffer, buffer));
    }
 
    Box2I erodedBy(Extent const & buffer) const { return dilatedBy(-buffer); }
    Box2I erodedBy(Element buffer) const { return dilatedBy(-buffer); }
 
    Box2I shiftedBy(Extent const & offset) const;
 
    Box2I reflectedAboutX(Element x) const;
 
    Box2I reflectedAboutY(Element y) const;
 
 
    Box2I expandedTo(Point const & other) const;
    Box2I expandedTo(Box2I const & other) const;
 
    Box2I clippedTo(Box2I const & other) const noexcept;
 
    bool operator==(Box2I const& other) const noexcept;
 
    bool operator!=(Box2I const& other) const noexcept;
 
    std::size_t hash_value() const noexcept;
 
    std::vector<Point2I> getCorners() const;
 
    std::string toString() const {
        return (boost::format("Box2I(%s,%s)") % _minimum.toString() % _dimensions.toString()).str();
    }
 
private:
    Point2I _minimum;
    Extent2I _dimensions;
};
 
class Box2D final {
public:
    typedef Point2D Point;
    typedef Extent2D Extent;
    typedef double Element;
 
    using Interval = IntervalD;
 
    static double const EPSILON;
 
    static double const INVALID;
 
    Box2D() noexcept;
 
    Box2D(Point2D const& minimum, Point2D const& maximum, bool invert = true) noexcept;
 
    Box2D(Point2D const& corner, Extent2D const& dimensions, bool invert = true) noexcept;
 
    Box2D(Interval const & x, Interval const & y) :
        Box2D(Point(x.getMin(), y.getMin()), Point(x.getMax(), y.getMax()), false)
    {}
 
    explicit Box2D(Box2I const& other) noexcept;
 
    Box2D(Box2D const&) noexcept = default;
    Box2D(Box2D&&) noexcept = default;
 
    ~Box2D() noexcept = default;
 
    // It's hard to guarantee postconditions (especially size) with non-finite inputs
    static Box2D makeCenteredBox(Point2D const& center, Extent const& size) noexcept;
 
    void swap(Box2D& other) noexcept {
        _minimum.swap(other._minimum);
        _maximum.swap(other._maximum);
    }
 
    Box2D& operator=(Box2D const&) noexcept = default;
    Box2D& operator=(Box2D&&) noexcept = default;
 
    Point2D const getMin() const noexcept { return _minimum; }
    double getMinX() const noexcept { return _minimum.getX(); }
    double getMinY() const noexcept { return _minimum.getY(); }
 
    Point2D const getMax() const noexcept { return _maximum; }
    double getMaxX() const noexcept { return _maximum.getX(); }
    double getMaxY() const noexcept { return _maximum.getY(); }
 
    Extent2D const getDimensions() const noexcept { return isEmpty() ? Extent2D(0.0) : _maximum - _minimum; }
    double getWidth() const noexcept { return isEmpty() ? 0 : _maximum.getX() - _minimum.getX(); }
    double getHeight() const noexcept { return isEmpty() ? 0 : _maximum.getY() - _minimum.getY(); }
    double getArea() const noexcept {
        Extent2D dim(getDimensions());
        return dim.getX() * dim.getY();
    }
 
 
    Interval getX() const { return Interval::fromMinMax(getMinX(), getMaxX()); }
    Interval getY() const { return Interval::fromMinMax(getMinY(), getMaxY()); }
 
    Point2D const getCenter() const noexcept {
        return Point2D((_minimum.asEigen() + _maximum.asEigen()) * 0.5);
    }
    double getCenterX() const noexcept { return (_minimum.getX() + _maximum.getX()) * 0.5; }
    double getCenterY() const noexcept { return (_minimum.getY() + _maximum.getY()) * 0.5; }
 
    bool isEmpty() const noexcept { return _minimum.getX() != _minimum.getX(); }
 
 
    bool contains(Point2D const& point) const noexcept;
    bool contains(Element x, Element y) const noexcept { return contains(Point2D(x, y)); }
 
    bool contains(Box2D const& other) const;
 
 
    bool overlaps(Box2D const& other) const noexcept;
    bool intersects(Box2D const& other) const noexcept { return overlaps(other); }
 
 
    bool isDisjointFrom(Box2D const & other) const noexcept;
 
    void grow(double buffer) { grow(Extent2D(buffer)); }
 
    void grow(Extent2D const& buffer);
 
    void shift(Extent2D const& offset);
 
    void flipLR(float xExtent);
 
    void flipTB(float yExtent);
 
    void include(Point2D const& point) noexcept;
 
    void include(Box2D const& other) noexcept;
 
    void clip(Box2D const& other) noexcept;
 
 
    Box2D dilatedBy(Extent const & buffer) const;
    Box2D dilatedBy(Element buffer) const {
        return dilatedBy(Extent(buffer, buffer));
    }
 
 
    Box2D erodedBy(Extent const & buffer) const { return dilatedBy(-buffer); }
    Box2D erodedBy(Element buffer) const { return dilatedBy(-buffer); }
 
    Box2D shiftedBy(Extent const & offset) const;
 
    Box2D reflectedAboutX(Element x) const;
 
    Box2D reflectedAboutY(Element y) const;
 
    Box2D expandedTo(Point const & other) const;
 
    Box2D expandedTo(Box2D const & other) const;
 
    Box2D clippedTo(Box2D const & other) const;
 
    bool operator==(Box2D const& other) const noexcept;
 
    bool operator!=(Box2D const& other) const noexcept;
 
    std::size_t hash_value() const noexcept;
 
    std::vector<Point2D> getCorners() const;
 
    std::string toString() const {
        return (boost::format("Box2D(%s,%s)") % _minimum.toString() % _maximum.toString()).str();
    }
 
private:
    void _tweakMax(int n) noexcept {
        if (_maximum[n] < 0.0) {
            _maximum[n] *= (1.0 - EPSILON);
        } else if (_maximum[n] > 0.0) {
            _maximum[n] *= (1.0 + EPSILON);
        } else {
            _maximum[n] = EPSILON;
        }
    }
    Point2D _minimum;
    Point2D _maximum;
};
 
typedef Box2D BoxD;
typedef Box2I BoxI;
 
std::ostream& operator<<(std::ostream& os, Box2I const& box);
 
std::ostream& operator<<(std::ostream& os, Box2D const& box);
 
}  // namespace geom
}  // namespace lsst
 
namespace std {
template <>
struct hash<lsst::geom::Box2I> {
    using argument_type = lsst::geom::Box2I;
    using result_type = size_t;
    size_t operator()(argument_type const& x) const noexcept { return x.hash_value(); }
};
 
template <>
struct hash<lsst::geom::Box2D> {
    using argument_type = lsst::geom::Box2D;
    using result_type = size_t;
    size_t operator()(argument_type const& x) const noexcept { return x.hash_value(); }
};
}  // namespace std
 
#endif