Java RobustLineIntersector类代码示例

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的package包/类
public OffsetSegmentGenerator(PrecisionModel precisionModel,
                              BufferParameters bufParams, double distance) {
    this.precisionModel = precisionModel;
    this.bufParams = bufParams;

    // compute intersections in full precision, to provide accuracy
    // the points are rounded as they are inserted into the curve line
    this.li = new RobustLineIntersector();
    this.filletAngleQuantum = Math.PI / 2.0 / bufParams.getQuadrantSegments();

    /**
     * Non-round joins cause issues with short closing segments, so don't use
     * them. In any case, non-round joins only really make sense for relatively
     * small buffer distances.
     */
    if (bufParams.getQuadrantSegments() >= 8
            && bufParams.getJoinStyle() == BufferParameters.JOIN_ROUND) {
        this.closingSegLengthFactor = MAX_CLOSING_SEG_LEN_FACTOR;
    }
    this.init(distance);
}
 

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的package包/类
public OffsetSegmentGenerator(PrecisionModel precisionModel,
    BufferParameters bufParams, double distance) {
  this.precisionModel = precisionModel;
  this.bufParams = bufParams;

  // compute intersections in full precision, to provide accuracy
  // the points are rounded as they are inserted into the curve line
  li = new RobustLineIntersector();
  filletAngleQuantum = Math.PI / 2.0 / bufParams.getQuadrantSegments();

  /**
   * Non-round joins cause issues with short closing segments, so don't use
   * them. In any case, non-round joins only really make sense for relatively
   * small buffer distances.
   */
  if (bufParams.getQuadrantSegments() >= 8
      && bufParams.getJoinStyle() == BufferParameters.JOIN_ROUND)
    closingSegLengthFactor = MAX_CLOSING_SEG_LEN_FACTOR;
  init(distance);
}
 

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的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.RobustLineIntersector; //导入依赖的package包/类
public void test2Lines() {
  RobustLineIntersector i = new RobustLineIntersector();
  Coordinate p1 = new Coordinate(10, 10);
  Coordinate p2 = new Coordinate(20, 20);
  Coordinate q1 = new Coordinate(20, 10);
  Coordinate q2 = new Coordinate(10, 20);
  Coordinate x = new Coordinate(15, 15);
  i.computeIntersection(p1, p2, q1, q2);
  assertEquals(RobustLineIntersector.POINT_INTERSECTION, i.getIntersectionNum());
  assertEquals(1, i.getIntersectionNum());
  assertEquals(x, i.getIntersection(0));
  assertTrue(i.isProper());
  assertTrue(i.hasIntersection());
}
 

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的package包/类
public void testCollinear1() {
  RobustLineIntersector i = new RobustLineIntersector();
  Coordinate p1 = new Coordinate(10, 10);
  Coordinate p2 = new Coordinate(20, 10);
  Coordinate q1 = new Coordinate(22, 10);
  Coordinate q2 = new Coordinate(30, 10);
  i.computeIntersection(p1, p2, q1, q2);
  assertEquals(RobustLineIntersector.NO_INTERSECTION, i.getIntersectionNum());
  assertTrue(!i.isProper());
  assertTrue(!i.hasIntersection());
}
 

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的package包/类
public void testCollinear2() {
  RobustLineIntersector i = new RobustLineIntersector();
  Coordinate p1 = new Coordinate(10, 10);
  Coordinate p2 = new Coordinate(20, 10);
  Coordinate q1 = new Coordinate(20, 10);
  Coordinate q2 = new Coordinate(30, 10);
  i.computeIntersection(p1, p2, q1, q2);
  assertEquals(RobustLineIntersector.POINT_INTERSECTION, i.getIntersectionNum());
  assertTrue(!i.isProper());
  assertTrue(i.hasIntersection());
}
 

import com.vividsolutions.jts.algorithm.RobustLineIntersector; //导入依赖的package包/类
public void testCollinear3() {
  RobustLineIntersector i = new RobustLineIntersector();
  Coordinate p1 = new Coordinate(10, 10);
  Coordinate p2 = new Coordinate(20, 10);
  Coordinate q1 = new Coordinate(15, 10);
  Coordinate q2 = new Coordinate(30, 10);
  i.computeIntersection(p1, p2, q1, q2);
  assertEquals(RobustLineIntersector.COLLINEAR_INTERSECTION, i.getIntersectionNum());
  assertTrue(!i.isProper());
  assertTrue(i.hasIntersection());
}