bounds.hpp

#pragma once

#include <ciso646>
#include <algorithm>
#include <tuple>

namespace simo
{
namespace shapes
{

struct bounds_t
{
    double minx;

    double miny;

    double maxx;

    double maxy;

    bounds_t()
        : minx(std::numeric_limits<double>::max()),
          miny(std::numeric_limits<double>::max()),
          maxx(std::numeric_limits<double>::min()),
          maxy(std::numeric_limits<double>::min())
    {
    }

    bounds_t(double minx, double miny, double maxx, double maxy)
        : minx(minx), miny(miny), maxx(maxx), maxy(maxy)
    {
    }

    bounds_t& extend(double x, double y)
    {
        minx = std::min(x, minx);
        maxx = std::max(x, maxx);
        miny = std::min(y, miny);
        maxy = std::max(y, maxy);
        return *this;
    }

    bounds_t& extend(const bounds_t& b)
    {
        minx = std::min(b.minx, minx);
        maxx = std::max(b.maxx, maxx);
        miny = std::min(b.miny, miny);
        maxy = std::max(b.maxy, maxy);
        return *this;
    }

    std::tuple<double, double> center() const
    {
        return std::make_tuple((minx + maxx) / 2.0, (miny + maxy) / 2.0);
    }

    std::tuple<double, double> bottom_left() const
    {
        return std::make_tuple(minx, maxy);
    }

    std::tuple<double, double> top_right() const
    {
        return std::make_tuple(maxx, miny);
    }

    std::tuple<double, double> top_left() const
    {
        return std::make_tuple(minx, miny);
    }

    std::tuple<double, double> bottom_right() const
    {
        return std::make_tuple(maxx, maxy);
    }

    bool contains(double x, double y) const
    {
        return (x >= minx) && (x <= maxx) && (y >= miny) && (y <= maxy);
    }

    bool contains(const bounds_t& other)
    {
        return contains(other.minx, other.miny) && contains(other.maxx, other.maxy);
    }

    bool intersects(const bounds_t& other)
    {
        return (other.maxx >= minx) && (other.minx <= maxx) && (other.maxy >= miny) && (other.miny <= maxy);
    }

    bool overlaps(const bounds_t& other)
    {
        return (other.maxx > minx) && (other.minx < maxx) && (other.maxy > miny) && (other.miny < maxy);
    }
};

}  // namespace shapes
}  // namespace simo