import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * Checks validity of a LinearRing.
 */
private void checkValid(LinearRing g) {
    this.checkInvalidCoordinates(g.getCoordinates());
    if (this.validErr != null) {
        return;
    }
    this.checkClosedRing(g);
    if (this.validErr != null) {
        return;
    }

    GeometryGraph graph = new GeometryGraph(0, g);
    this.checkTooFewPoints(graph);
    if (this.validErr != null) {
        return;
    }
    LineIntersector li = new RobustLineIntersector();
    graph.computeSelfNodes(li, true);
    this.checkNoSelfIntersectingRings(graph);
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private boolean isSimpleLinearGeometry(Geometry geom) {
    if (geom.isEmpty()) {
        return true;
    }
    GeometryGraph graph = new GeometryGraph(0, geom);
    LineIntersector li = new RobustLineIntersector();
    SegmentIntersector si = graph.computeSelfNodes(li, true);
    // if no self-intersection, must be simple
    if (!si.hasIntersection()) {
        return true;
    }
    if (si.hasProperIntersection()) {
        this.nonSimpleLocation = si.getProperIntersectionPoint();
        return false;
    }
    if (this.hasNonEndpointIntersection(graph)) {
        return false;
    }
    if (this.isClosedEndpointsInInterior) {
        if (this.hasClosedEndpointIntersection(graph)) {
            return false;
        }
    }
    return true;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private Noder getNoder(PrecisionModel precisionModel) {
        if (this.workingNoder != null) {
            return this.workingNoder;
        }

        // otherwise use a fast (but non-robust) noder
        MCIndexNoder noder = new MCIndexNoder();
        LineIntersector li = new RobustLineIntersector();
        li.setPrecisionModel(precisionModel);
        noder.setSegmentIntersector(new IntersectionAdder(li));
//    Noder noder = new IteratedNoder(precisionModel);
        return noder;
//    Noder noder = new SimpleSnapRounder(precisionModel);
//    Noder noder = new MCIndexSnapRounder(precisionModel);
//    Noder noder = new ScaledNoder(new MCIndexSnapRounder(new PrecisionModel(1.0)),
//                                  precisionModel.getScale());
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * Creates a new hot pixel, using a given scale factor.
 * The scale factor must be strictly positive (non-zero).
 *
 * @param pt the coordinate at the centre of the pixel
 * @param scaleFactor the scaleFactor determining the pixel size.  Must be > 0
 * @param li the intersector to use for testing intersection with line segments
 */
public HotPixel(Coordinate pt, double scaleFactor, LineIntersector li) {
    this.originalPt = pt;
    this.pt = pt;
    this.scaleFactor = scaleFactor;
    this.li = li;
    //tolerance = 0.5;
    if (scaleFactor <= 0) {
        throw new IllegalArgumentException("Scale factor must be non-zero");
    }
    if (scaleFactor != 1.0) {
        this.pt = new Coordinate(this.scale(pt.x), this.scale(pt.y));
        this.p0Scaled = new Coordinate();
        this.p1Scaled = new Coordinate();
    }
    this.initCorners(this.pt);
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
     * Compute self-nodes, taking advantage of the Geometry type to
     * minimize the number of intersection tests.  (E.g. rings are
     * not tested for self-intersection, since they are assumed to be valid).
     *
     * @param li the LineIntersector to use
     * @param computeRingSelfNodes if <false>, intersection checks are optimized to not test rings for self-intersection
     * @return the SegmentIntersector used, containing information about the intersections found
     */
    public SegmentIntersector computeSelfNodes(LineIntersector li, boolean computeRingSelfNodes) {
        SegmentIntersector si = new SegmentIntersector(li, true, false);
        EdgeSetIntersector esi = this.createEdgeSetIntersector();
        // optimized test for Polygons and Rings
        if (!computeRingSelfNodes
                && (this.parentGeom instanceof LinearRing
                || this.parentGeom instanceof Polygon
                || this.parentGeom instanceof MultiPolygon)) {
            esi.computeIntersections(this.edges, si, false);
        } else {
            esi.computeIntersections(this.edges, si, true);
        }
//System.out.println("SegmentIntersector # tests = " + si.numTests);
        this.addSelfIntersectionNodes(this.argIndex);
        return si;
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
public SegmentIntersector computeEdgeIntersections(
            GeometryGraph g,
            LineIntersector li,
            boolean includeProper) {
        SegmentIntersector si = new SegmentIntersector(li, includeProper, true);
        si.setBoundaryNodes(this.getBoundaryNodes(), g.getBoundaryNodes());

        EdgeSetIntersector esi = this.createEdgeSetIntersector();
        esi.computeIntersections(this.edges, g.edges, si);
/*
for (Iterator i = g.edges.iterator(); i.hasNext();) {
Edge e = (Edge) i.next();
Debug.print(e.getEdgeIntersectionList());
}
*/
        return si;
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * Checks if the point is located on the given {@link LineSegment} (including endpoints).
 */
public static boolean isPointOnLineSegment(Coordinate point, LineSegment line) {
    double lengthOfLine = line.getLength();
    double distFromEnd1 = point.distance(line.p0);
    double distFromEnd2 = point.distance(line.p1);

    // this seems to handle robustness errors (due to rounding) better
    if (distFromEnd1 + distFromEnd2 == lengthOfLine) {
        return true;
    }

    // Fallback to what should probably be the robust implementation (TODO: investigate precision issues)
    LineIntersector lineIntersector = new RobustLineIntersector();
    lineIntersector.computeIntersection(point, line.p0, line.p1);
    return lineIntersector.hasIntersection();
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private boolean isSimpleLinearGeometry(Geometry geom) {
    if (geom.isEmpty()) return true;
    GeometryGraph graph = new GeometryGraph(0, geom);
    LineIntersector li = new RobustLineIntersector();
    SegmentIntersector si = graph.computeSelfNodes(li, true);
    // if no self-intersection, must be simple
    if (!si.hasIntersection()) return true;
    if (si.hasProperIntersection()) {
        nonSimpleLocation = si.getProperIntersectionPoint();
        return false;
    }
    if (hasNonEndpointIntersection(graph)) return false;
    if (isClosedEndpointsInInterior) {
        if (hasClosedEndpointIntersection(graph)) return false;
    }
    return true;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * Creates a new hot pixel, using a given scale factor.
 * The scale factor must be strictly positive (non-zero).
 *
 * @param pt          the coordinate at the centre of the pixel
 * @param scaleFactor the scaleFactor determining the pixel size.  Must be > 0
 * @param li          the intersector to use for testing intersection with line segments
 */
public HotPixel(Coordinate pt, double scaleFactor, LineIntersector li) {
    originalPt = pt;
    this.pt = pt;
    this.scaleFactor = scaleFactor;
    this.li = li;
    //tolerance = 0.5;
    if (scaleFactor <= 0)
        throw new IllegalArgumentException("Scale factor must be non-zero");
    if (scaleFactor != 1.0) {
        this.pt = new Coordinate(scale(pt.x), scale(pt.y));
        p0Scaled = new Coordinate();
        p1Scaled = new Coordinate();
    }
    initCorners(this.pt);
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
     * Compute self-nodes, taking advantage of the Geometry type to
     * minimize the number of intersection tests.  (E.g. rings are
     * not tested for self-intersection, since they are assumed to be valid).
     *
     * @param li                   the LineIntersector to use
     * @param computeRingSelfNodes if <false>, intersection checks are optimized to not test rings for self-intersection
     * @return the SegmentIntersector used, containing information about the intersections found
     */
    public SegmentIntersector computeSelfNodes(LineIntersector li, boolean computeRingSelfNodes) {
        SegmentIntersector si = new SegmentIntersector(li, true, false);
        EdgeSetIntersector esi = createEdgeSetIntersector();
        // optimized test for Polygons and Rings
        if (!computeRingSelfNodes
                && (parentGeom instanceof LinearRing
                || parentGeom instanceof Polygon
                || parentGeom instanceof MultiPolygon)) {
            esi.computeIntersections(edges, si, false);
        } else {
            esi.computeIntersections(edges, si, true);
        }
//System.out.println("SegmentIntersector # tests = " + si.numTests);
        addSelfIntersectionNodes(argIndex);
        return si;
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
public SegmentIntersector computeEdgeIntersections(
            GeometryGraph g,
            LineIntersector li,
            boolean includeProper) {
        SegmentIntersector si = new SegmentIntersector(li, includeProper, true);
        si.setBoundaryNodes(this.getBoundaryNodes(), g.getBoundaryNodes());

        EdgeSetIntersector esi = createEdgeSetIntersector();
        esi.computeIntersections(edges, g.edges, si);
/*
for (Iterator i = g.edges.iterator(); i.hasNext();) {
Edge e = (Edge) i.next();
Debug.print(e.getEdgeIntersectionList());
}
*/
        return si;
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * @return true if there is an intersection point which is not an endpoint of the segment p0-p1
 */
private boolean hasInteriorIntersection(LineIntersector li, Coordinate p0, Coordinate p1) {
    for (int i = 0; i < li.getIntersectionNum(); i++) {
        Coordinate intPt = li.getIntersection(i);
        if (!(intPt.equals(p0) || intPt.equals(p1))) {
            return true;
        }
    }
    return false;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private boolean isBoundaryPoint(LineIntersector li, Collection[] bdyNodes) {
    if (bdyNodes == null) {
        return false;
    }
    if (this.isBoundaryPoint(li, bdyNodes[0])) {
        return true;
    }
    return isBoundaryPoint(li, bdyNodes[1]);
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
     * Add an EdgeIntersection for intersection intIndex.
     * An intersection that falls exactly on a vertex of the edge is normalized
     * to use the higher of the two possible segmentIndexes
     */
    public void addIntersection(LineIntersector li, int segmentIndex, int geomIndex, int intIndex) {
        Coordinate intPt = new Coordinate(li.getIntersection(intIndex));
        int normalizedSegmentIndex = segmentIndex;
        double dist = li.getEdgeDistance(geomIndex, intIndex);
//Debug.println("edge intpt: " + intPt + " dist: " + dist);
        // normalize the intersection point location
        int nextSegIndex = normalizedSegmentIndex + 1;
        if (nextSegIndex < this.pts.length) {
            Coordinate nextPt = this.pts[nextSegIndex];
//Debug.println("next pt: " + nextPt);

            // Normalize segment index if intPt falls on vertex
            // The check for point equality is 2D only - Z values are ignored
            if (intPt.equals2D(nextPt)) {
//Debug.println("normalized distance");
                normalizedSegmentIndex = nextSegIndex;
                dist = 0.0;
            }
        }
        /**
         * Add the intersection point to edge intersection list.
         */
        EdgeIntersection ei = this.eiList.add(intPt, normalizedSegmentIndex, dist);
//ei.print(System.out);

    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private void findAndClassifyIntersections(Geometry geom) {
    List lineSegStr = SegmentStringUtil.extractSegmentStrings(geom);

    LineIntersector li = new RobustLineIntersector();
    SegmentIntersectionDetector intDetector = new SegmentIntersectionDetector(li);
    intDetector.setFindAllIntersectionTypes(true);
    this.prepPoly.getIntersectionFinder().intersects(lineSegStr, intDetector);

    this.hasSegmentIntersection = intDetector.hasIntersection();
    this.hasProperIntersection = intDetector.hasProperIntersection();
    this.hasNonProperIntersection = intDetector.hasNonProperIntersection();
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * Checks if the line intersects any of the edges of given polygon.<br>
 * Start and end points of the line can only touch, but not cross the edges of polygon.
 *
 * @param line line which might intersect the edges of polygon
 * @param polygon the polygon
 * @return true if line intersects at least one edge of the polygon
 */
public static boolean isIntersectingPolygon(LineSegment line, Polygon polygon) {
    LineIntersector lineIntersector = new RobustLineIntersector();

    List<LineSegment> edges = getLineSegments(polygon.getExteriorRing());
    for (LineSegment edge : edges) {
        lineIntersector.computeIntersection(line.p0, line.p1, edge.p0, edge.p1);
        if (lineIntersector.hasIntersection() && lineIntersector.isProper()) {      // intersection exists and is not one of the endpoints of the line
            return true;
        }
    }
    return false;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
LineString fullClosedLine(List<LineString> lines) {
    List<Coordinate> tail = new ArrayList<>();

    boolean found;
    do {
        found = false;
        for (int i = 0; i < lines.size(); i++) {
            if (addToClosed(tail, lines.get(i))) {
                lines.remove(i);
                i--;
                found = true;
            }
        }
    } while (found);

    LineString s = GeometryHelper.createLine(tail);
    if (!s.isClosed()) {
        throw new RuntimeException("Non-closed line starts from " + tail.get(0) + " ends to "
                + tail.get(tail.size() - 1));
    }
    if (!s.isSimple()) {
        GeometryGraph graph = new GeometryGraph(0, s);
        LineIntersector li = new RobustLineIntersector();
        SegmentIntersector si = graph.computeSelfNodes(li, true);
        if (si.hasProperInteriorIntersection()) {
            throw new RuntimeException("Self-intersection for " + relation.getObjectCode()
                    + " near point " + si.getProperIntersectionPoint());
        }else {
            throw new RuntimeException("Self-intersected line: " + s);
        }
    }
    return s;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private Noder getNoder(PrecisionModel precisionModel) {
        if (workingNoder != null) return workingNoder;

        // otherwise use a fast (but non-robust) noder
        MCIndexNoder noder = new MCIndexNoder();
        LineIntersector li = new RobustLineIntersector();
        li.setPrecisionModel(precisionModel);
        noder.setSegmentIntersector(new IntersectionAdder(li));
//    Noder noder = new IteratedNoder(precisionModel);
        return noder;
//    Noder noder = new SimpleSnapRounder(precisionModel);
//    Noder noder = new MCIndexSnapRounder(precisionModel);
//    Noder noder = new ScaledNoder(new MCIndexSnapRounder(new PrecisionModel(1.0)),
//                                  precisionModel.getScale());
    }
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
/**
 * @return true if there is an intersection point which is not an endpoint of the segment p0-p1
 */
private boolean hasInteriorIntersection(LineIntersector li, Coordinate p0, Coordinate p1) {
    for (int i = 0; i < li.getIntersectionNum(); i++) {
        Coordinate intPt = li.getIntersection(i);
        if (!(intPt.equals(p0) || intPt.equals(p1)))
            return true;
    }
    return false;
}
 

import com.vividsolutions.jts.algorithm.LineIntersector; //导入依赖的package包/类
private boolean isBoundaryPoint(LineIntersector li, Collection bdyNodes) {
    for (Iterator i = bdyNodes.iterator(); i.hasNext(); ) {
        Node node = (Node) i.next();
        Coordinate pt = node.getCoordinate();
        if (li.isIntersection(pt)) return true;
    }
    return false;
}