Пример #1
0
 private Pair<Point2D, Point2D> getAPointInReachblePartEdges(Area area, Edge relatedEdge) {
   Point2D point = null;
   Edge rEdge = null;
   if (area instanceof Road) {
     Road road = (Road) area;
     FOR:
     for (SOSArea reachablePart : road.getReachableParts()) {
       for (Edge edge : reachablePart.getEdges()) {
         if (edge.getReachablityIndex() >= 0
             && area.getEdges().get(edge.getReachablityIndex()).equals(relatedEdge)) {
           point = edge.getMidPoint();
           rEdge = edge;
           break FOR;
         }
       }
     }
   }
   if (point == null) {
     point = relatedEdge.getMidPoint();
     rEdge = relatedEdge;
   }
   ArrayList<Point2D> twoPointForCheckContain =
       Utility.get2PointsAroundAPointOutOfLine(rEdge.getStart(), rEdge.getEnd(), point, 10);
   ArrayList<Point2D> twoPoint =
       Utility.get2PointsAroundAPointOutOfLine(rEdge.getStart(), rEdge.getEnd(), point, 3000);
   if (area.getShape().contains(twoPointForCheckContain.get(0).toGeomPoint()))
     return new Pair<Point2D, Point2D>(twoPoint.get(0), twoPoint.get(1));
   else return new Pair<Point2D, Point2D>(twoPoint.get(1), twoPoint.get(0));
 }
Пример #2
0
 // Morteza2011*****************************************************************
 public static Pair<ArrayList<Edge>, ArrayList<Edge>> splitEdges(
     ArrayList<Edge> edgeList1, List<Edge> edgeList2) {
   ArrayList<ArrayList<Pair<Point2D, Point2D>>> pointList1 =
       new ArrayList<ArrayList<Pair<Point2D, Point2D>>>();
   ArrayList<ArrayList<Pair<Point2D, Point2D>>> pointList2 =
       new ArrayList<ArrayList<Pair<Point2D, Point2D>>>();
   for (short i = 0; i < edgeList1.size(); i++) {
     pointList1.add(new ArrayList<Pair<Point2D, Point2D>>());
     pointList1
         .get(i)
         .add(
             new Pair<Point2D, Point2D>(edgeList1.get(i).getStart(), edgeList1.get(i).getStart()));
     pointList1
         .get(i)
         .add(new Pair<Point2D, Point2D>(edgeList1.get(i).getStart(), edgeList1.get(i).getEnd()));
   }
   for (short i = 0; i < edgeList2.size(); i++) {
     pointList2.add(new ArrayList<Pair<Point2D, Point2D>>());
     pointList2
         .get(i)
         .add(
             new Pair<Point2D, Point2D>(edgeList2.get(i).getStart(), edgeList2.get(i).getStart()));
     pointList2
         .get(i)
         .add(new Pair<Point2D, Point2D>(edgeList2.get(i).getStart(), edgeList2.get(i).getEnd()));
   }
   for (short i = 0; i < edgeList1.size(); i++) {
     for (short j = 0; j < edgeList2.size(); j++) {
       Point2D intersect = Utility.getIntersect(edgeList1.get(i), edgeList2.get(j));
       if (intersect != null) {
         pointList1.get(i).add(new Pair<Point2D, Point2D>(edgeList1.get(i).getStart(), intersect));
         pointList2.get(j).add(new Pair<Point2D, Point2D>(edgeList2.get(j).getStart(), intersect));
       }
     }
   }
   for (short i = 0; i < edgeList1.size(); i++) {
     sortPoints(pointList1.get(i));
   }
   for (short i = 0; i < edgeList2.size(); i++) {
     sortPoints(pointList2.get(i));
   }
   ArrayList<Edge> newEdges1 = new ArrayList<Edge>();
   ArrayList<Edge> newEdges2 = new ArrayList<Edge>();
   for (short i = 0; i < pointList1.size(); i++) {
     for (short j = 0; j < pointList1.get(i).size() - 1; j++) {
       Edge e = new Edge(pointList1.get(i).get(j).second(), pointList1.get(i).get(j + 1).second());
       newEdges1.add(e);
     }
   }
   for (short i = 0; i < pointList2.size(); i++) {
     for (short j = 0; j < pointList2.get(i).size() - 1; j++) {
       Edge e = new Edge(pointList2.get(i).get(j).second(), pointList2.get(i).get(j + 1).second());
       newEdges2.add(e);
     }
   }
   return new Pair<ArrayList<Edge>, ArrayList<Edge>>(newEdges1, newEdges2);
 }
Пример #3
0
  private void computeCenter(int[] apexes) {

    rescuecore2.geometry.Point2D p = SOSGeometryTools.computeCentroid(apexes);
    centerX = (int) p.getX();
    centerY = (int) p.getY();
    if (apexes.length < 6) return;
    try {
      Point2D point1 = null, point2 = null, middlePoint = null;
      ArrayList<rescuecore2.geometry.Point2D> twoPointOutOfLine = null;
      if (!contains(centerX, centerY)) { // if the point is not inside the polygon
        /////////////////////// finding a point inside polygon////////////////
        FOR:
        for (int i = 0; i < apexes.length - 2; i += 2) {
          point1 = new rescuecore2.geometry.Point2D(apexes[i], apexes[i + 1]);
          point2 = new rescuecore2.geometry.Point2D(apexes[i + 2], apexes[i + 3]);
          middlePoint =
              new rescuecore2.geometry.Point2D(
                  (apexes[i] + apexes[i + 2]) / 2, (apexes[i + 1] + apexes[i + 3]) / 2);
          twoPointOutOfLine =
              Utility.get2PointsAroundAPointOutOfLine(point1, point2, middlePoint, 2);
          for (rescuecore2.geometry.Point2D point2d : twoPointOutOfLine) {
            if (contains(point2d.getX(), point2d.getY())) {
              centerX = (int) point2d.getX();
              centerY = (int) point2d.getY();
              break FOR;
            }
          }
        }
        /*
        if (!contains(centerX, centerY)) {
        	debug.show("SOS Shape", new ShapeDebugFrame.AWTShapeInfo(this, "apexes=" + Arrays.toString(apexes), Color.blue, false),
        			new ShapeDebugFrame.Point2DShapeInfo(point1, "Point 1", Color.red, true),
        			new ShapeDebugFrame.Point2DShapeInfo(point2, "Point 2", Color.green, true),
        			new ShapeDebugFrame.Point2DShapeInfo(middlePoint, "middlePoint", Color.pink, true),
        			new ShapeDebugFrame.Point2DShapeInfo(twoPointOutOfLine.get(0), "twoPointOutOfLine 1", Color.magenta, true),
        			new ShapeDebugFrame.Point2DShapeInfo(twoPointOutOfLine.get(1), "twoPointOutOfLine 2", Color.black, true),
        			new ShapeDebugFrame.DetailInfo("area:" + SOSGeometryTools.computeAreaUnsigned(apexes))
        			);
        }
        */
        ///////////////////////////////////////////////////////////////////////
      }
    } catch (Exception e) {
      e.printStackTrace();
      System.err.println(this.getClass().getSimpleName() + " have error" + e.getMessage());
    }
  }
Пример #4
0
 // Morteza2012*****************************************************************
 public ArrayList<Road> checkNeighborRoads() {
   ArrayList<Road> rs = new ArrayList<Road>();
   for (Area a : position.getNeighbours()) {
     if (a instanceof Road) {
       Road r = ((Road) a);
       if (Utility.hasIntersect(expandedBlock, r.getExpandedArea())) {
         if (!r.getNeighborBlockades().contains(this)) {
           rs.add(r);
           r.getNeighborBlockades().remove(this);
           r.getNeighborBlockades().add(this);
         }
       } else if (r.getNeighborBlockades().contains(this)) {
         r.getNeighborBlockades().remove(this);
         rs.add(r);
       }
     }
   }
   rs.add(position);
   return rs;
 }
Пример #5
0
  // Morteza2011*****************************************************************
  public static ArrayList<SOSArea> mergeBlockades(Road road, ArrayList<SOSArea> blockades) {
    // log(road).logln("RoadID:" + road.getID());
    //		for (SOSArea b : blockades) {
    // log(road).logln(b.getReachablityBlockades());
    //		}
    for (short i = 0; i < blockades.size(); i++) {
      for (short j = (short) (i + 1); j < blockades.size(); j++) {
        if (Utility.hasIntersect(blockades.get(i), blockades.get(j))) {
          SOSArea a1 = blockades.get(i);
          SOSArea a2 = blockades.get(j);
          SOSArea a3;
          try {
            a3 = merge(road, a1, a2, (short) (0));
          } catch (Exception e) {
            a3 = reMerge(a1, a2);
            e.printStackTrace();
          }

          blockades.remove(j--);
          if (!a3.getEdges().isEmpty()) {
            blockades.set(i, a3);
          }
          i--;
          break;
        } else {
          try {
            if (blockades
                .get(i)
                .getShape()
                .contains(
                    blockades.get(j).getEdges().get(0).getStart().getX(),
                    blockades.get(j).getEdges().get(0).getStart().getY())) {
              // log(road).logln(blockades.get(j)+" has included in "+blockades.get(i));
              blockades.get(i).addReachablityBlockades(blockades.get(j).getReachablityBlockades());
              blockades.remove(j--);
            } else {
              if (blockades
                  .get(j)
                  .getShape()
                  .contains(
                      blockades.get(i).getEdges().get(0).getStart().getX(),
                      blockades.get(i).getEdges().get(0).getStart().getY())) {
                // log(road).logln(blockades.get(i)+" has included in "+blockades.get(j));
                blockades
                    .get(j)
                    .addReachablityBlockades(blockades.get(i).getReachablityBlockades());
                blockades.remove(i--);
                break;
              }
              // else
              // log(road).logln("intersect:no and included:no!");

            }
          } catch (Exception e) {
            try {
              e.printStackTrace();
              SOSArea a1 = blockades.get(i);
              SOSArea a2 = blockades.get(j);
              SOSArea a3;
              a3 = reMerge(a1, a2);
              blockades.remove(j--);
              if (!a3.getEdges().isEmpty()) {
                blockades.set(i, a3);
              }
              i--;
              break;
            } catch (Exception e1) {

            }
          }
        }
      }
    }
    return blockades;
  }