コード例 #1
0
 @Override
 public boolean equals(final Object obj) {
   if (this == obj) {
     return true;
   }
   if (obj == null) {
     return false;
   }
   if (getClass() != obj.getClass()) {
     return false;
   }
   final Edge other = (Edge) obj;
   if (end == null) {
     if (other.end != null) {
       return false;
     }
   } else if (!end.equals(other.end)) {
     return false;
   }
   if (start == null) {
     if (other.start != null) {
       return false;
     }
   } else if (!start.equals(other.start)) {
     return false;
   }
   return true;
 }
コード例 #2
0
  public void findEdge(List dirEdgeList) {
    /**
     * Check all forward DirectedEdges only. This is still general, because each edge has a forward
     * DirectedEdge.
     */
    for (Iterator i = dirEdgeList.iterator(); i.hasNext(); ) {
      DirectedEdge de = (DirectedEdge) i.next();
      if (!de.isForward()) continue;
      checkForRightmostCoordinate(de);
    }

    /**
     * If the rightmost point is a node, we need to identify which of the incident edges is
     * rightmost.
     */
    Assert.isTrue(
        minIndex != 0 || minCoord.equals(minDe.getCoordinate()),
        "inconsistency in rightmost processing");
    if (minIndex == 0) {
      findRightmostEdgeAtNode();
    } else {
      findRightmostEdgeAtVertex();
    }
    /** now check that the extreme side is the R side. If not, use the sym instead. */
    orientedDe = minDe;
    int rightmostSide = getRightmostSide(minDe, minIndex);
    if (rightmostSide == Position.LEFT) {
      orientedDe = minDe.getSym();
    }
  }
コード例 #3
0
 public void computeIntersection(Coordinate p, Coordinate p1, Coordinate p2) {
   isProper = false;
   // do between check first, since it is faster than the orientation test
   if (Envelope.intersects(p1, p2, p)) {
     if ((CGAlgorithms.orientationIndex(p1, p2, p) == 0)
         && (CGAlgorithms.orientationIndex(p2, p1, p) == 0)) {
       isProper = true;
       if (p.equals(p1) || p.equals(p2)) {
         isProper = false;
       }
       result = POINT_INTERSECTION;
       return;
     }
   }
   result = NO_INTERSECTION;
 }
コード例 #4
0
 @Test
 public void testGetCoordinateCopy() throws Exception {
   // geom independance: changing returned coordinate does not change sequence.
   Coordinate co = testSeq2D.getCoordinateCopy(1);
   co.x = co.x + 1;
   assertFalse(co.equals(testSeq2D.getCoordinateCopy(1)));
 }
コード例 #5
0
ファイル: NodeOsm.java プロジェクト: AnderPijoan/cat2osm
 @Override
 public synchronized boolean equals(Object obj) {
   if (obj == null) return false;
   if (this == obj) return true;
   if (getClass() != obj.getClass()) return false;
   NodeOsm other = (NodeOsm) obj;
   if (coor == null) {
     if (other.coor != null) return false;
   } else if (!coor.equals(other.coor)) return false;
   return true;
 }
コード例 #6
0
  private int computeCollinearIntersection(
      Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2) {
    boolean p1q1p2 = Envelope.intersects(p1, p2, q1);
    boolean p1q2p2 = Envelope.intersects(p1, p2, q2);
    boolean q1p1q2 = Envelope.intersects(q1, q2, p1);
    boolean q1p2q2 = Envelope.intersects(q1, q2, p2);

    if (p1q1p2 && p1q2p2) {
      intPt[0] = q1;
      intPt[1] = q2;
      return COLLINEAR_INTERSECTION;
    }
    if (q1p1q2 && q1p2q2) {
      intPt[0] = p1;
      intPt[1] = p2;
      return COLLINEAR_INTERSECTION;
    }
    if (p1q1p2 && q1p1q2) {
      intPt[0] = q1;
      intPt[1] = p1;
      return q1.equals(p1) && !p1q2p2 && !q1p2q2 ? POINT_INTERSECTION : COLLINEAR_INTERSECTION;
    }
    if (p1q1p2 && q1p2q2) {
      intPt[0] = q1;
      intPt[1] = p2;
      return q1.equals(p2) && !p1q2p2 && !q1p1q2 ? POINT_INTERSECTION : COLLINEAR_INTERSECTION;
    }
    if (p1q2p2 && q1p1q2) {
      intPt[0] = q2;
      intPt[1] = p1;
      return q2.equals(p1) && !p1q1p2 && !q1p2q2 ? POINT_INTERSECTION : COLLINEAR_INTERSECTION;
    }
    if (p1q2p2 && q1p2q2) {
      intPt[0] = q2;
      intPt[1] = p2;
      return q2.equals(p2) && !p1q1p2 && !q1p1q2 ? POINT_INTERSECTION : COLLINEAR_INTERSECTION;
    }
    return NO_INTERSECTION;
  }
コード例 #7
0
 private void distribute(AddressNodeGroup group) {
   List<AddressNode> nodes = group.getAddressNodes();
   Collections.sort(nodes, addressNodeComparator);
   Coordinate start = group.getGeometry().getCoordinate();
   // center of the building
   Coordinate center = group.getBuilding().getGeometry().getCentroid().getCoordinate();
   double dx;
   double dy;
   if (start.equals(center)) {
     // if the nodes are at the center of the building, use an angle of 45 degrees
     dx = SQRT2 * DISTANCE;
     dy = SQRT2 * DISTANCE;
   } else {
     double angle = new LineSegment(start, center).angle();
     dx = Math.cos(angle) * DISTANCE;
     dy = Math.sin(angle) * DISTANCE;
   }
   double x = group.getGeometry().getX();
   double y = group.getGeometry().getY();
   //        List<Command> cmds = new LinkedList<>();
   for (AddressNode node : nodes) {
     Point point = geoUtil.toPoint(new Coordinate(x, y));
     node.setGeometry(point);
     //            Command cmd = node.updateGeometry(point);
     //            if (cmd != null) {
     //                cmds.add(cmd);
     //            }
     x = x + dx;
     y = y + dy;
   }
   //        if (!nodes.isEmpty()) {
   //            final SequenceCommand sequenceCommand = new SequenceCommand(
   //                I18n.tr("Distribute {0} address nodes.", cmds.size()), cmds);
   //            Main.main.undoRedo.add(sequenceCommand);
   //        }
 }
コード例 #8
0
  /**
   * Split the graph by splitting an Edge at a point into 2 Edges
   *
   * @param c coordinates at which to split the graph
   * @param iSplit split index (the i-th split point, used to create the new edge IDs)
   */
  public void splitGraphAtPoint(Coordinate c, int iSplit) {
    Edge nearestEdge = null;
    float nearestDist = kNearestEdgeDistance;
    while (nearestEdge == null && nearestDist / kNearestEdgeDistance < 20.) {
      nearestEdge = findNearestEdge(c, nearestDist);
      if (nearestEdge == null) {
        nearestDist *= 2.;
        logger.info("Increasing kNearestEdgeDistance: " + nearestDist);
      }
    }
    // get the projected point on the nearest edge

    PointPairDistance ppd = new PointPairDistance();
    @SuppressWarnings("rawtypes")
    LineString nearestLineString = (LineString) ((HashMap) nearestEdge.getData()).get("geom");
    EuclideanDistanceToPoint.computeDistance(nearestLineString, c, ppd);

    Coordinate resultcoord = null;

    for (Coordinate cc : ppd.getCoordinates()) {
      // System.out.println(cc);
      if (cc.equals(c) == false) {
        resultcoord = cc;
      }
    }

    // let us loop through the vertices

    Coordinate[] nearestLineStringCoordinates = nearestLineString.getCoordinates();

    ArrayList<Coordinate> fromVertices = new ArrayList<Coordinate>();
    ArrayList<Coordinate> toVertices = new ArrayList<Coordinate>();
    fromVertices.add(nearestLineStringCoordinates[0]);
    boolean isAfter = false;

    for (int i = 1; i < nearestLineStringCoordinates.length; i++) {
      Coordinate pt0 = nearestLineStringCoordinates[i - 1];
      Coordinate pt1 = nearestLineStringCoordinates[i];

      // let us build a segment between 2 nodes

      Coordinate[] segmentCoords = {pt0, pt1};
      LineString segment = fact.createLineString(segmentCoords);

      // let us check whether the projected point (resultcoord) is on the node

      if (fact.createPoint(resultcoord).distance(segment) < SPLITSNAPDISTANCE) {
        // point within, let us split
        fromVertices.add(resultcoord);
        toVertices.add(resultcoord);
        isAfter = true;
      } else {
        if (!isAfter) {
          fromVertices.add(nearestLineStringCoordinates[i]);
        } else {
          toVertices.add(nearestLineStringCoordinates[i]);
        }
      }
    }
    // if (nearestLineStringCoordinates.length==2) {
    toVertices.add(nearestLineStringCoordinates[nearestLineStringCoordinates.length - 1]);
    // }

    // TODO: generate nice edge ids here
    int id1 = -2 * iSplit - 1;
    int id2 = -2 * iSplit - 2;
    // replace straight lines with lines including vertices
    Coordinate[] fromArray = new Coordinate[fromVertices.size()];
    Coordinate[] toArray = new Coordinate[toVertices.size()];

    fromVertices.toArray(fromArray);
    toVertices.toArray(toArray);

    addLineString(fact.createLineString(fromArray), id1);
    addLineString(fact.createLineString(toArray), id2);

    this.removeEdge(nearestEdge);

    System.out.println("Graph split @ " + resultcoord);
  }
コード例 #9
0
 /**
  * Tests whether a given point is in an array of points. Uses a value-based test.
  *
  * @param pt a {@link Coordinate} for the test point
  * @param pts an array of {@link Coordinate}s to test
  * @return <code>true</code> if the point is in the array
  * @deprecated
  */
 public static boolean isInList(Coordinate pt, Coordinate[] pts) {
   for (int i = 0; i < pts.length; i++) {
     if (pt.equals(pts[i])) return true;
   }
   return false;
 }