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=NULL)
                :
                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