LineSegment.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2009 2011 Sandro Santilli <strk@kbt.io>
 * Copyright (C) 2005-2006 Refractions Research Inc.
 * Copyright (C) 2001-2002 Vivid Solutions 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/LineSegment.java r18 (JTS-1.11)
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.h>
#include <geos/geom/Coordinate.h> // for composition
#include <geos/geom/LineSegment.h>
#include <geos/algorithm/Distance.h>
#include <geos/algorithm/Orientation.h>
 
#include <array>
#include <iostream> // for ostream
#include <functional> // for std::hash
#include <memory> // for unique_ptr
#include <cassert>
#include <unordered_set>
 
// Forward declarations
namespace geos {
namespace geom {
class CoordinateSequence;
class GeometryFactory;
class LineString;
}
}
 
namespace geos {
namespace geom { // geos::geom
 
class GEOS_DLL LineSegment {
public:
 
 
    Coordinate p0; 
    Coordinate p1; 
 
    LineSegment(const Coordinate& c0, const Coordinate& c1)
        : p0(c0)
        , p1(c1)
        {};
 
    LineSegment(double x0, double y0, double x1, double y1)
        : p0(x0, y0)
        , p1(x1, y1)
        {};
 
    LineSegment() {};
 
 
    void setCoordinates(const Coordinate& c0, const Coordinate& c1)
    {
        p0 = c0;
        p1 = c1;
    };
 
    void setCoordinates(const LineSegment& ls)
    {
        setCoordinates(ls.p0, ls.p1);
    };
 
    // obsoleted, use operator[] instead
    //const Coordinate& getCoordinate(std::size_t i) const;
 
    const Coordinate& operator[](std::size_t i) const
    {
        if(i == 0) {
            return p0;
        }
        assert(i == 1);
        return p1;
    };
 
    Coordinate& operator[](std::size_t i)
    {
        if(i == 0) {
            return p0;
        }
        assert(i == 1);
        return p1;
    };
 
    double minX() const
    {
        return std::min(p0.x, p1.x);
    };
 
    double maxX() const
    {
        return std::max(p0.x, p1.x);
    };
 
    double minY() const
    {
        return std::min(p0.y, p1.y);
    };
 
    double maxY() const
    {
        return std::max(p0.y, p1.y);
    };
 
    double getLength() const
    {
        return p0.distance(p1);
    };
 
    bool isHorizontal() const
    {
        return p0.y == p1.y;
    };
 
    bool isVertical() const
    {
        return p0.x == p1.x;
    };
 
    int orientationIndex(const LineSegment& seg) const;
 
    // TODO deprecate this
    int orientationIndex(const LineSegment* seg) const
    {
        assert(seg);
        return orientationIndex(*seg);
    };
 
    int orientationIndex(const CoordinateXY& p) const
    {
        return algorithm::Orientation::index(p0, p1, p);
    }
 
    int orientationIndex(const Coordinate& p) const
    {
        return algorithm::Orientation::index(p0, p1, p);
    };
 
    void reverse();
 
    //
    void normalize()
    {
        if(p1.compareTo(p0) < 0) {
            reverse();
        }
    };
 
    double angle() const
    {
        return std::atan2(p1.y - p0.y, p1.x - p0.x);
    };
 
    CoordinateXY midPoint() const
    {
        return midPoint(p0, p1);
    };
 
    static CoordinateXY midPoint(const CoordinateXY& pt0, const CoordinateXY& pt1)
    {
        return CoordinateXY(
            (pt0.x + pt1.x) / 2,
            (pt0.y + pt1.y) / 2);        
    }
 
    double distance(const LineSegment& ls) const
    {
        return algorithm::Distance::segmentToSegment(p0, p1, ls.p0, ls.p1);
    };
 
    double distance(const CoordinateXY& p) const
    {
        return algorithm::Distance::pointToSegment(p, p0, p1);
    };
 
    double distancePerpendicular(const CoordinateXY& p) const
    {
        if (p0.equals2D(p1))
            return p0.distance(p);
        return algorithm::Distance::pointToLinePerpendicular(p, p0, p1);
    };
 
    double distancePerpendicularOriented(const CoordinateXY& p) const;
 
    void pointAlong(double segmentLengthFraction, Coordinate& ret) const
    {
        ret = Coordinate(
            p0.x + segmentLengthFraction * (p1.x - p0.x),
            p0.y + segmentLengthFraction * (p1.y - p0.y),
            p0.z + segmentLengthFraction * (p1.z - p0.z));
    };
 
    static CoordinateXY pointAlong(double segmentLengthFraction, const CoordinateXY& p0, const CoordinateXY& p1)
    {
        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
                 p0.y + segmentLengthFraction * (p1.y - p0.y) };
    }
 
    static Coordinate pointAlong(double segmentLengthFraction, const Coordinate& p0, const Coordinate& p1)
    {
        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
                 p0.y + segmentLengthFraction * (p1.y - p0.y),
                 p0.z + segmentLengthFraction * (p1.z - p0.z) };
    }
 
    static CoordinateXYM pointAlong(double segmentLengthFraction, const CoordinateXYM& p0, const CoordinateXYM& p1)
    {
        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
                 p0.y + segmentLengthFraction * (p1.y - p0.y),
                 p0.m + segmentLengthFraction * (p1.m - p0.m) };
    }
 
    static CoordinateXYZM pointAlong(double segmentLengthFraction, const CoordinateXYZM& p0, const CoordinateXYZM& p1)
    {
        return { p0.x + segmentLengthFraction * (p1.x - p0.x),
                 p0.y + segmentLengthFraction * (p1.y - p0.y),
                 p0.z + segmentLengthFraction * (p1.z - p0.z),
                 p0.m + segmentLengthFraction * (p1.m - p0.m) };
    }
 
    void pointAlongOffset(double segmentLengthFraction,
                          double offsetDistance,
                          Coordinate& ret) const;
 
 
    LineSegment offset(double offsetDistance);
 
 
    double projectionFactor(const CoordinateXY& p) const;
 
    static double projectionFactor(const CoordinateXY& p0, const CoordinateXY& p1, const CoordinateXY& q);
 
    double segmentFraction(const CoordinateXY& inputPt) const;
 
    void project(const Coordinate& p, Coordinate& ret) const;
 
    CoordinateXY project(const CoordinateXY& p) const;
 
    static CoordinateXY project(const CoordinateXY& p0, const CoordinateXY& p1, const CoordinateXY& q);
 
    bool project(const LineSegment& seg, LineSegment& ret) const;
 
    //
    void closestPoint(const CoordinateXY& p, CoordinateXY& ret) const;
 
    static CoordinateXY closestPoint(const CoordinateXY& p0, const CoordinateXY& p1,
                                     const CoordinateXY& q);
 
    bool equalsTopo(const LineSegment& other) const;
 
    std::array<Coordinate, 2> closestPoints(const LineSegment& line);
 
    std::array<Coordinate, 2> closestPoints(const LineSegment* line)
    {
        assert(line);
        return closestPoints(*line);
    }
 
    static std::array<CoordinateXY, 2> closestPoints(const CoordinateXY& p0,
                                                     const CoordinateXY& p1,
                                                     const CoordinateXY& q0,
                                                     const CoordinateXY& q1);
 
    Coordinate intersection(const LineSegment& line) const;
 
    Coordinate lineIntersection(const LineSegment& line) const;
 
    std::unique_ptr<LineString> toGeometry(const GeometryFactory& gf) const;
 
 
    inline int compareTo(const LineSegment& other) const
    {
        int comp0 = p0.compareTo(other.p0);
        if (comp0 != 0) {
            return comp0;
        }
        return p1.compareTo(other.p1);
    }
 
    std::ostream& operator<< (std::ostream& o);
 
    inline bool operator==(const LineSegment& rhs) const {
        return compareTo(rhs) == 0;
    };
 
    inline bool operator<(const LineSegment& rhs) const {
        return compareTo(rhs) < 0;
    };
 
    inline bool operator>(const LineSegment& rhs) const {
        return compareTo(rhs) > 0;
    };
 
    struct HashCode {
        inline std::size_t operator()(const LineSegment & s) const {
            std::size_t h = std::hash<double>{}(s.p0.x);
            h ^= (std::hash<double>{}(s.p0.y) << 1);
            h ^= (std::hash<double>{}(s.p1.x) << 1);
            return h ^ (std::hash<double>{}(s.p1.y) << 1);
        }
 
        inline std::size_t operator()(const LineSegment * s) const {
            std::size_t h = std::hash<double>{}(s->p0.x);
            h ^= (std::hash<double>{}(s->p0.y) << 1);
            h ^= (std::hash<double>{}(s->p1.x) << 1);
            return h ^ (std::hash<double>{}(s->p1.y) << 1);
        }
 
    };
 
    using UnorderedSet = std::unordered_set<LineSegment, HashCode>;
 
 
private:
    static CoordinateXY project(const CoordinateXY& p0, const CoordinateXY& p1, double factor);
 
    void project(double factor, CoordinateXY& ret) const;
 
};
 
 
// std::ostream& operator<< (std::ostream& o, const LineSegment& l);
 
 
} // namespace geos::geom
} // namespace geos