Example #1
0
 /**
  * Computes the (approximate) intersection point between two line segments using homogeneous
  * coordinates.
  *
  * <p>Note that this algorithm is not numerically stable; i.e. it can produce intersection points
  * which lie outside the envelope of the line segments themselves. In order to increase the
  * precision of the calculation input points should be normalized before passing them to this
  * routine.
  */
 public static Coordinate intersection(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)
     throws NotRepresentableException {
   HCoordinate l1 = new HCoordinate(new HCoordinate(p1), new HCoordinate(p2));
   HCoordinate l2 = new HCoordinate(new HCoordinate(q1), new HCoordinate(q2));
   HCoordinate intHCoord = new HCoordinate(l1, l2);
   Coordinate intPt = intHCoord.getCoordinate();
   return intPt;
 }
Example #2
0
  /**
   * Adds a mitre join connecting the two reflex offset segments. The mitre will be beveled if it
   * exceeds the mitre ratio limit.
   *
   * @param offset0 the first offset segment
   * @param offset1 the second offset segment
   * @param distance the offset distance
   */
  private void addMitreJoin(
      final Coordinate p,
      final LineSegment offset0,
      final LineSegment offset1,
      final double distance) {
    boolean isMitreWithinLimit = true;
    Coordinate intPt = null;

    /**
     * This computation is unstable if the offset segments are nearly collinear. Howver, this
     * situation should have been eliminated earlier by the check for whether the offset segment
     * endpoints are almost coincident
     */
    try {
      intPt = HCoordinate.intersection(offset0.p0, offset0.p1, offset1.p0, offset1.p1);

      final double mitreRatio = distance <= 0.0 ? 1.0 : intPt.distance(p) / Math.abs(distance);

      if (mitreRatio > m_bufferParams.getMitreLimit()) isMitreWithinLimit = false;
    } catch (final NotRepresentableException ex) {
      intPt = new Coordinate(0, 0);
      isMitreWithinLimit = false;
    }

    if (isMitreWithinLimit) {
      m_bufferBuilder.addVertices(intPt);
    } else {
      addLimitedMitreJoin(distance, m_bufferParams.getMitreLimit());
    }
  }
 /**
  * Computes the intersection point of the lines of infinite extent defined by two line segments
  * (if there is one). There may be 0, 1 or an infinite number of intersection points between two
  * lines. If there is a unique intersection point, it is returned. Otherwise, <tt>null</tt> is
  * returned. If more information is required about the details of the intersection, the {@link
  * RobustLineIntersector} class should be used.
  *
  * @param line a line segment defining an straight line with infinite extent
  * @return an intersection point, or <code>null</code> if there is no point of intersection or an
  *     infinite number of intersection points
  * @see RobustLineIntersector
  */
 public Coordinate lineIntersection(LineSegment line) {
   try {
     Coordinate intPt = HCoordinate.intersection(p0, p1, line.p0, line.p1);
     return intPt;
   } catch (NotRepresentableException ex) {
     // eat this exception, and return null;
   }
   return null;
 }
 /**
  * Computes a segment intersection using homogeneous coordinates. Round-off error can cause the
  * raw computation to fail, (usually due to the segments being approximately parallel). If this
  * happens, a reasonable approximation is computed instead.
  *
  * @param p1 a segment endpoint
  * @param p2 a segment endpoint
  * @param q1 a segment endpoint
  * @param q2 a segment endpoint
  * @return the computed intersection point
  */
 private Coordinate safeHCoordinateIntersection(
     Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2) {
   Coordinate intPt = null;
   try {
     intPt = HCoordinate.intersection(p1, p2, q1, q2);
   } catch (NotRepresentableException e) {
     //    	System.out.println("Not calculable: " + this);
     // compute an approximate result
     //      intPt = CentralEndpointIntersector.getIntersection(p1, p2, q1, q2);
     intPt = nearestEndpoint(p1, p2, q1, q2);
     //     System.out.println("Snapped to " + intPt);
   }
   return intPt;
 }