Envelope.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2006 Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: geom/Envelope.java rev 1.46 (JTS-1.10)
 *
 **********************************************************************/
 
#pragma once
 
 
#include <geos/export.h>
#include <geos/geom/Coordinate.h>
 
#include <string>
#include <vector>
#include <ostream> // for operator<<
#include <memory>
#include <cassert>
#include <algorithm>
 
namespace geos {
namespace geom { // geos::geom
 
class Envelope;
 
GEOS_DLL std::ostream& operator<< (std::ostream& os, const Envelope& o);
 
class Coordinate;
 
class GEOS_DLL Envelope {
 
public:
 
    friend std::ostream& operator<< (std::ostream& os, const Envelope& o);
 
    typedef std::unique_ptr<Envelope> Ptr;
 
    Envelope()
        : minx(DoubleNotANumber)
        , maxx(DoubleNotANumber)
        , miny(DoubleNotANumber)
        , maxy(DoubleNotANumber)
        {};
 
    Envelope(double x1, double x2, double y1, double y2)
    {
        init(x1, x2, y1, y2);
    }
 
    Envelope(const CoordinateXY& p1, const CoordinateXY& p2)
    {
        init(p1, p2);
    }
 
    explicit Envelope(const CoordinateXY& p)
        : minx(p.x)
        , maxx(p.x)
        , miny(p.y)
        , maxy(p.y)
    {
    }
 
    explicit Envelope(const std::string& str);
 
    static bool intersects(const CoordinateXY& p1, const CoordinateXY& p2,
                           const CoordinateXY& q);
 
    static bool intersects(
        const CoordinateXY& p1, const CoordinateXY& p2,
        const CoordinateXY& q1, const CoordinateXY& q2)
    {
        double minq = std::min(q1.x, q2.x);
        double maxq = std::max(q1.x, q2.x);
        double minp = std::min(p1.x, p2.x);
        double maxp = std::max(p1.x, p2.x);
        if(minp > maxq) {
            return false;
        }
        if(maxp < minq) {
            return false;
        }
        minq = std::min(q1.y, q2.y);
        maxq = std::max(q1.y, q2.y);
        minp = std::min(p1.y, p2.y);
        maxp = std::max(p1.y, p2.y);
        if(minp > maxq) {
            return false;
        }
        if(maxp < minq) {
            return false;
        }
        return true;
    }
 
    bool intersects(const CoordinateXY& a, const CoordinateXY& b) const;
 
    void init()
    {
        setToNull();
    };
 
    void init(double x1, double x2, double y1, double y2)
    {
        if(x1 < x2) {
            minx = x1;
            maxx = x2;
        }
        else {
            minx = x2;
            maxx = x1;
        }
        if(y1 < y2) {
            miny = y1;
            maxy = y2;
        }
        else {
            miny = y2;
            maxy = y1;
        }
    };
 
    void init(const CoordinateXY& p1, const CoordinateXY& p2)
    {
        init(p1.x, p2.x, p1.y, p2.y);
    };
 
    void init(const CoordinateXY& p)
    {
        init(p.x, p.x, p.y, p.y);
    };
 
    void setToNull()
    {
        minx = maxx = miny = maxy = DoubleNotANumber;
    };
 
    bool isNull(void) const
    {
        return std::isnan(maxx);
    };
 
    double getWidth() const
    {
        if(isNull()) {
            return 0;
        }
        return maxx - minx;
    }
 
    double getHeight() const
    {
        if(isNull()) {
            return 0;
        }
        return maxy - miny;
    }
 
    double
    getArea() const
    {
        return getWidth() * getHeight();
    }
 
    double
    getPerimeter() const
    {
        return 2*getWidth() + 2*getHeight();
    }
 
    bool
    isFinite() const
    {
        return std::isfinite(getArea());
    }
 
    double getMaxY() const
    {
        assert(!isNull());
        return maxy;
    };
 
    double getMaxX() const
    {
        assert(!isNull());
        return maxx;
    };
 
    double getMinY() const
    {
        assert(!isNull());
        return miny;
    };
 
    double getMinX() const
    {
        assert(!isNull());
        return minx;
    };
 
    double getDiameter() const
    {
        if (isNull()) {
            return 0.0;
        }
        double w = getWidth();
        double h = getHeight();
        return std::sqrt(w*w + h*h);
    }
 
    bool centre(CoordinateXY& centre) const;
 
    bool intersection(const Envelope& env, Envelope& result) const;
 
    Envelope intersection(const Envelope& env) const;
 
    void translate(double transX, double transY);
 
    void expandBy(double deltaX, double deltaY);
 
    void
    expandBy(double p_distance)
    {
        expandBy(p_distance, p_distance);
    };
 
    void expandToInclude(const CoordinateXY& p)
    {
        expandToInclude(p.x, p.y);
    };
 
    void expandToInclude(double x, double y)
    {
        if(isNull()) {
            minx = x;
            maxx = x;
            miny = y;
            maxy = y;
        }
        else {
            if(x < minx) {
                minx = x;
            }
            if(x > maxx) {
                maxx = x;
            }
            if(y < miny) {
                miny = y;
            }
            if(y > maxy) {
                maxy = y;
            }
        }
    };
 
    void expandToInclude(const Envelope* other)
    {
        if(isNull()) {
            minx = other->minx;
            maxx = other->maxx;
            miny = other->miny;
            maxy = other->maxy;
        }
        else {
            if(std::isless(other->minx, minx)) {
                minx = other->minx;
            }
            if(std::isgreater(other->maxx, maxx)) {
                maxx = other->maxx;
            }
            if(std::isless(other->miny, miny)) {
                miny = other->miny;
            }
            if(std::isgreater(other->maxy, maxy)) {
                maxy = other->maxy;
            }
        }
    };
 
    void expandToInclude(const Envelope& other)
    {
        return expandToInclude(&other);
    };
 
    bool
    contains(const Envelope& other) const
    {
        return covers(other);
    }
 
    bool
    contains(const Envelope* other) const
    {
        return contains(*other);
    }
 
    bool
    contains(const CoordinateXY& p) const
    {
        return covers(p.x, p.y);
    }
 
    bool
    contains(double x, double y) const
    {
        return covers(x, y);
    }
 
    bool
    containsProperly(const CoordinateXY& p) const
    {
        return std::isless(p.x, maxx) && std::isgreater(p.x, minx) &&
                std::isless(p.y, maxy) && std::isgreater(p.y,  miny);
    }
 
    bool intersects(const CoordinateXY& other) const
    {
        return (std::islessequal(other.x, maxx) && std::isgreaterequal(other.x, minx) &&
                std::islessequal(other.y, maxy) && std::isgreaterequal(other.y,  miny));
    }
 
    bool intersects(double x, double y) const
    {
        return std::islessequal(x, maxx) &&
               std::isgreaterequal(x, minx) &&
               std::islessequal(y, maxy) &&
               std::isgreaterequal(y, miny);
    }
 
    bool intersects(const Envelope* other) const
    {
        return std::islessequal(other->minx, maxx) &&
               std::isgreaterequal(other->maxx, minx) &&
               std::islessequal(other->miny, maxy) &&
               std::isgreaterequal(other->maxy, miny);
    }
 
    bool intersects(const Envelope& other) const
    {
        return intersects(&other);
    }
 
    bool disjoint(const Envelope& other) const
    {
        return !intersects(other);
    }
 
    bool disjoint(const Envelope* other) const
    {
        return !intersects(other);
    }
 
    bool covers(double x, double y) const {
        return std::isgreaterequal(x,  minx) &&
               std::islessequal(x, maxx) &&
               std::isgreaterequal(y, miny) &&
               std::islessequal(y,  maxy);
    }
 
    bool covers(const CoordinateXY* p) const
    {
        return covers(p->x, p->y);
    }
 
    bool covers(const Envelope& other) const;
 
    bool
    covers(const Envelope* other) const
    {
        return covers(*other);
    }
 
 
    bool equals(const Envelope* other) const;
 
    bool isfinite() const;
 
    std::string toString() const;
 
    double distance(const Envelope& env) const
    {
        return std::sqrt(distanceSquared(env));
    }
 
    double maxDistance(const Envelope& other) const
    {
        Coordinate p(std::min(minx, other.minx), std::min(miny, other.miny));
        Coordinate q(std::max(maxx, other.maxx), std::max(maxy, other.maxy));
        return p.distance(q);
    }
 
    double distanceSquared(const Envelope& env) const
    {
        double dx = std::max(0.0,
            std::max(maxx, env.maxx) - std::min(minx, env.minx) - (maxx - minx) -
            (env.maxx - env.minx));
        double dy = std::max(0.0,
            std::max(maxy, env.maxy) - std::min(miny, env.miny) - (maxy - miny) -
            (env.maxy - env.miny));
 
        return dx * dx + dy * dy;
    };
 
    static double distanceToCoordinate(
        const CoordinateXY& c,
        const CoordinateXY& p0,
        const CoordinateXY& p1)
    {
        return std::sqrt(distanceSquaredToCoordinate(c, p0, p1));
    };
 
    static double distanceSquaredToCoordinate(
        const CoordinateXY& c,
        const CoordinateXY& p0,
        const CoordinateXY& p1)
    {
        double xa = c.x - p0.x;
        double xb = c.x - p1.x;
        double ya = c.y - p0.y;
        double yb = c.y - p1.y;
 
        // If sign of a and b are not the same, then Envelope spans c and distance is zero.
        double dx = (std::signbit(xa) == std::signbit(xb)) * std::min(std::abs(xa), std::abs(xb));
        double dy = (std::signbit(ya) == std::signbit(yb)) * std::min(std::abs(ya), std::abs(yb));
 
        return dx*dx + dy*dy;
    }
 
    std::size_t hashCode() const
    {
        auto hash = std::hash<double>{};
 
        //Algorithm from Effective Java by Joshua Bloch [Jon Aquino]
        std::size_t result = 17;
        result = 37 * result + hash(minx);
        result = 37 * result + hash(maxx);
        result = 37 * result + hash(miny);
        result = 37 * result + hash(maxy);
        return result;
    }
 
    struct GEOS_DLL HashCode
    {
        std::size_t operator()(const Envelope& e) const
        {
            return e.hashCode();
        };
    };
 
    // GEOS_DLL bool operator==(const Envelope& a, const Envelope& b);
    GEOS_DLL friend bool
    operator==(const Envelope& a, const Envelope& b)
    {
        return a.equals(&b);
    }
 
    // GEOS_DLL bool operator!=(const Envelope& a, const Envelope& b);
    GEOS_DLL friend bool
    operator!=(const Envelope& a, const Envelope& b)
    {
        return !(a == b);
    }
 
    GEOS_DLL friend bool
    operator< (const Envelope& a, const Envelope& b);
 
private:
 
    static std::vector<std::string> split(const std::string& str,
                                   const std::string& delimiters = " ");
 
    static double distance(double x0, double y0, double x1, double y1)
    {
        double dx = x1 - x0;
        double dy = y1 - y0;
        return std::sqrt(dx * dx + dy * dy);
    }
 
    double minx;
 
    double maxx;
 
    double miny;
 
    double maxy;
};
 
 
 
 
} // namespace geos::geom
} // namespace geos