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 Coordinate& p1, const Coordinate& p2)
    {
        init(p1, p2);
    }
 
    explicit Envelope(const Coordinate& p)
    {
        init(p);
    }
 
    explicit Envelope(const std::string& str);
 
    static bool intersects(const Coordinate& p1, const Coordinate& p2,
                           const Coordinate& q);
 
    static bool intersects(
        const Coordinate& p1, const Coordinate& p2,
        const Coordinate& q1, const Coordinate& 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 Coordinate& a, const Coordinate& 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 Coordinate& p1, const Coordinate& p2)
    {
        init(p1.x, p2.x, p1.y, p2.y);
    };
 
    void init(const Coordinate& 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 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(Coordinate& centre) const;
 
    bool intersection(const Envelope& env, Envelope& result) 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 Coordinate& 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(other->minx < minx) {
                minx = other->minx;
            }
            if(other->maxx > maxx) {
                maxx = other->maxx;
            }
            if(other->miny < miny) {
                miny = other->miny;
            }
            if(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 Coordinate& p) const
    {
        return covers(p.x, p.y);
    }
 
    bool
    contains(double x, double y) const
    {
        return covers(x, y);
    }
 
    bool intersects(const Coordinate& other) const
    {
        return (other.x <= maxx && other.x >= minx &&
                other.y <= maxy && other.y >= miny);
    }
 
    bool intersects(double x, double y) const
    {
        return (x <= maxx && x >= minx && y <= maxy && y >= miny);
    }
 
    bool intersects(const Envelope* other) const
    {
        return other->minx <= maxx &&
               other->maxx >= minx &&
               other->miny <= maxy &&
               other->maxy >= miny;
    }
 
    bool intersects(const Envelope& other) const
    {
        return intersects(&other);
    }
 
    bool disjoint(const Envelope& other) const
    {
        return disjoint(&other);
    }
 
    bool disjoint(const Envelope* other) const
    {
        return !(other->minx <= maxx ||
                 other->maxx >= minx ||
                 other->miny <= maxy ||
                 other->maxy >= miny);
    }
 
    bool covers(double x, double y) const;
 
    bool covers(const Coordinate* 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;
 
    std::string toString() const;
 
    double distance(const Envelope& env) const
    {
        return std::sqrt(distanceSquared(env));
    }
 
    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 Coordinate& c,
        const Coordinate& p0,
        const Coordinate& p1)
    {
        return std::sqrt(distanceSquaredToCoordinate(c, p0, p1));
    };
 
    static double distanceSquaredToCoordinate(
        const Coordinate& c,
        const Coordinate& p0,
        const Coordinate& 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;
 
    // 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