LineIntersector.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * 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: algorithm/RobustLineIntersector.java r785 (JTS-1.13+)
 *
 **********************************************************************/
 
#ifndef GEOS_ALGORITHM_LINEINTERSECTOR_H
#define GEOS_ALGORITHM_LINEINTERSECTOR_H
 
#include <geos/export.h>
#include <string>
 
#include <geos/geom/Coordinate.h>
 
// Forward declarations
namespace geos {
        namespace geom {
                class PrecisionModel;
        }
}
 
namespace geos {
namespace algorithm { // geos::algorithm
 
class GEOS_DLL LineIntersector {
public:
 
        static double interpolateZ(const geom::Coordinate &p, const geom::Coordinate &p0, const geom::Coordinate &p1);
 
 
        //
        static double computeEdgeDistance(const geom::Coordinate& p, const geom::Coordinate& p0, const geom::Coordinate& p1);
 
        static double nonRobustComputeEdgeDistance(const geom::Coordinate& p,const geom::Coordinate& p1,const geom::Coordinate& p2);
 
        LineIntersector(const geom::PrecisionModel* initialPrecisionModel=nullptr)
                :
                precisionModel(initialPrecisionModel),
                result(0),
                isProperVar(false)
        {}
 
        ~LineIntersector() {}
 
        bool isInteriorIntersection();
 
        bool isInteriorIntersection(int inputLineIndex);
 
        //
        void setPrecisionModel(const geom::PrecisionModel *newPM) {
                precisionModel=newPM;
        }
 
        //
        void computeIntersection(const geom::Coordinate& p, const geom::Coordinate& p1, const geom::Coordinate& p2);
 
        static bool hasIntersection(const geom::Coordinate& p,const geom::Coordinate& p1,const geom::Coordinate& p2);
 
        // These are deprecated, due to ambiguous naming
        enum {
                DONT_INTERSECT=0,
                DO_INTERSECT=1,
                COLLINEAR=2
        };
 
        enum {
                NO_INTERSECTION=0,
 
                POINT_INTERSECTION=1,
 
                COLLINEAR_INTERSECTION=2
        };
 
        void computeIntersection(const geom::Coordinate& p1, const geom::Coordinate& p2,
                        const geom::Coordinate& p3, const geom::Coordinate& p4);
 
        std::string toString() const;
 
        bool hasIntersection() const { return result!=NO_INTERSECTION; }
 
        //
        int getIntersectionNum() const { return result; }
 
 
        //
        const geom::Coordinate& getIntersection(int intIndex) const {
                return intPt[intIndex];
        }
 
        //
        static bool isSameSignAndNonZero(double a,double b);
 
        bool isIntersection(const geom::Coordinate& pt) const;
 
        bool isProper() const {
                return hasIntersection()&&isProperVar;
        }
 
        const geom::Coordinate& getIntersectionAlongSegment(int segmentIndex,int intIndex);
 
        int getIndexAlongSegment(int segmentIndex,int intIndex);
 
        double getEdgeDistance(int geomIndex,int intIndex) const;
 
private:
 
        void intersectionWithNormalization(const geom::Coordinate& p1,
                const geom::Coordinate& p2,
                const geom::Coordinate& q1,
                const geom::Coordinate& q2,
                geom::Coordinate &ret) const;
 
        const geom::PrecisionModel *precisionModel;
 
        int result;
 
        const geom::Coordinate *inputLines[2][2];
 
        geom::Coordinate intPt[2];
 
        int intLineIndex[2][2];
 
        bool isProperVar;
        //Coordinate &pa;
        //Coordinate &pb;
 
        bool isCollinear() const { return result==COLLINEAR_INTERSECTION; }
 
        int computeIntersect(const geom::Coordinate& p1,const geom::Coordinate& p2,const geom::Coordinate& q1,const geom::Coordinate& q2);
 
        bool isEndPoint() const {
                return hasIntersection()&&!isProperVar;
        }
 
        void computeIntLineIndex();
 
        void computeIntLineIndex(int segmentIndex);
 
        int computeCollinearIntersection(const geom::Coordinate& p1,
                const geom::Coordinate& p2, const geom::Coordinate& q1,
                const geom::Coordinate& q2);
 
        void intersection(const geom::Coordinate& p1,
                const geom::Coordinate& p2,
                const geom::Coordinate& q1,
                const geom::Coordinate& q2,
                geom::Coordinate &ret) const;
 
        double smallestInAbsValue(double x1, double x2,
                double x3, double x4) const;
 
        bool isInSegmentEnvelopes(const geom::Coordinate& intPt) const;
 
        void normalizeToEnvCentre(geom::Coordinate &n00, geom::Coordinate &n01,
                geom::Coordinate &n10, geom::Coordinate &n11,
                geom::Coordinate &normPt) const;
 
         void safeHCoordinateIntersection(const geom::Coordinate& p1,
                         const geom::Coordinate& p2,
                         const geom::Coordinate& q1,
                         const geom::Coordinate& q2,
                         geom::Coordinate& intPt) const;
 
};
 
} // namespace geos::algorithm
} // namespace geos
 
 
#endif // GEOS_ALGORITHM_LINEINTERSECTOR_H