Ejemplo n.º 1
0
 private int addNeighbors(List<Acre> left, List<Acre> right) {
   assert left.size() == right.size();
   int count = 0;
   for (int i = 0, j = left.size(); i < j; i++) {
     Acre l = left.get(i);
     Acre r = right.get(i);
     if (l != null && r != null) {
       l.addNeighbor(r, indexOfMyNeighbor(l, r));
       r.addNeighbor(l, indexOfMyNeighbor(r, l));
       count++;
     }
   }
   return count;
 }
Ejemplo n.º 2
0
 private void assignVertexIds() {
   pointLocator = new PointLocator();
   for (Acre acre : sector.getInnerAcres()) {
     Point[] midpoints = AcreSeamSeq.buildMidpoints(acre);
     acre.seamStartVertexIds = buildSeamStarts(acre.packId, midpoints);
     acre.zoneStartVertexIds = buildZoneStarts(acre.packId, acre.points.length);
     acre.topographyDef = buildTopographyDef(acre.center, acre.points);
   }
   for (Acre acre : sector.getSharedAcres()) {
     Point[] midpoints = AcreSeamSeq.buildMidpoints(acre);
     acre.seamStartVertexIds = buildSeamStarts(acre.packId, midpoints);
     acre.zoneStartVertexIds = buildZoneStarts(acre.packId, acre.points.length);
     acre.topographyDef = buildTopographyDef(acre.center, acre.points);
   }
 }
Ejemplo n.º 3
0
  public static void main(String[] args) {
    final Set<String> show =
        new HashSet<String>(Arrays.asList("point$ triangles acres neighbors sectors".split(" ")));
    //        final Set<String> show = new HashSet<String>(Arrays.asList("global-sectors
    // sectors".split(" ")));
    final Map<Long, Acre> acresByID = new HashMap<Long, Acre>();
    Consumer<Acre> acreConsumer =
        new Consumer<Acre>() {
          public void consume(Acre acre) {
            assert !acresByID.containsKey(acre.id);
            acresByID.put(acre.id, acre);
          }
        };

    Point[] points = {
      new Point(1.0, -1000.0, Math.sqrt(3) * -0.5),
      new Point(-1.0, -1000.0, Math.sqrt(3) * -0.5),
      new Point(0.0, -1000.0, Math.sqrt(3) * 0.5)
    };
    GeoPoint[] geoPoints = {
      GeoPoint.fromPoint(points[0]), GeoPoint.fromPoint(points[1]), GeoPoint.fromPoint(points[2])
    };
    for (int i = 0; i < 3; i++) {
      points[i] = geoPoints[i].toPoint(1000.0);
    }

    final OutputGraph out = new OutputGraph("Acres", new Dimension(2048, 2048), 0.0, 0.0, 1000.0);
    out.onClose(
        new Runnable() {
          public void run() {
            System.exit(0);
          }
        });

    Sector.MAP_ACRES_BY_CENTER_POINT.set(true);
    final GlobalSector gs = new GlobalSector(0, Globe.INSTANCE, geoPoints);
    final AtomicReference<Sector[]> sectors = new AtomicReference<Sector[]>();
    gs.setInit(
        gs.new Initializer(5, points[0], points[1], points[2], false, null) {

          @Override
          protected Sector[] getChildren(int length) {
            sectors.set(super.getChildren(length));
            return sectors.get();
          }

          @Override
          protected Sector buildChild(
              int index,
              GeoPoint a,
              GeoPoint b,
              GeoPoint c,
              Point i,
              Point j,
              Point k,
              boolean inverted) {
            TestSector sector = new TestSector(index, inverted, gs, new GeoPoint[] {a, b, c});
            sector.setInit(sector.new TestInitializer(new Point[] {i, j, k}, show, out));
            sectors.get()[index] = sector;
            return sector;
          }
        });
    gs.getInit().run();
    for (Sector s : sectors.get()) {
      s.getInit().run();
      s.edgesBuilt = new AtomicInteger();
    }
    if (show.contains("global-sectors")) {
      Point a = gs.points[0].toPoint(1000.0);
      Point b = gs.points[1].toPoint(1000.0);
      Point c = gs.points[2].toPoint(1000.0);
      double x = (a.x + b.x + c.x) / 3.0;
      double y = (a.z + b.z + c.z) / 3.0;
      if (show.contains("labels")) {
        out.addLabel(Color.orange, gs.getIDString(), x, y + 0.075);
      }
      x *= -0.02;
      y *= -0.02;
      out.addLine(
          Color.orange,
          a.x * 1.02 + x,
          a.z * 1.02 + y,
          b.x * 1.02 + x,
          b.z * 1.02 + y,
          c.x * 1.02 + x,
          c.z * 1.02 + y,
          a.x * 1.02 + x,
          a.z * 1.02 + y);
    }
    if (show.contains("sectors")) {
      for (Sector s : sectors.get()) {
        Point a = s.points[0].toPoint(1000.0);
        Point b = s.points[1].toPoint(1000.0);
        Point c = s.points[2].toPoint(1000.0);
        out.addLine(Color.magenta, a.x, a.z, b.x, b.z, c.x, c.z, a.x, a.z);
        if (show.contains("labels")) {
          double x = (a.x + b.x + c.x) / 3.0;
          double y = (a.z + b.z + c.z) / 3.0;
          out.addLabel(Color.magenta, s.getIDString(), x, y);
        }
      }
    }
    GeoFactory.combinePoints(Arrays.<GeoPointBasedElement>asList(sectors.get()), Globe.INSTANCE);
    Map<GeoPoint, Sector[]> sectorMap = new HashMap<GeoPoint, Sector[]>();
    for (Sector s : sectors.get()) {
      GeoFactory.addSectorByPoint(sectorMap, s, s.points[0]);
      GeoFactory.addSectorByPoint(sectorMap, s, s.points[1]);
      GeoFactory.addSectorByPoint(sectorMap, s, s.points[2]);
    }
    Collection<AcreBuilder> builders = new ArrayList<AcreBuilder>();
    for (final Sector s : sectors.get()) {
      builders.add(
          new AcreBuilder(
              GeoSpec.SECTOR_DIVISIONS.iGet(), false, s, sectorMap, null, acreConsumer) {

            @Override
            protected int[] findNearCornerAcres() {
              int[] nearCornerAcres = super.findNearCornerAcres();
              if (show.contains("near-edge-acres")) {
                System.out.println("Corner A: " + nearCornerAcres[0]);
                System.out.println("Corner B: " + nearCornerAcres[1]);
                System.out.println("Corner C: " + nearCornerAcres[2]);
              }
              return nearCornerAcres;
            }

            @Override
            protected Map<Edge, int[]> findNearEdgeAcres() {
              Map<Edge, int[]> nearEdgeAcres = super.findNearEdgeAcres();
              if (show.contains("near-edge-acres")) {
                System.out.println("Edge AB: " + Arrays.toString(nearEdgeAcres.get(Edge.AB)));
                System.out.println("Edge BC: " + Arrays.toString(nearEdgeAcres.get(Edge.BC)));
                System.out.println("Edge CA: " + Arrays.toString(nearEdgeAcres.get(Edge.CA)));
              }
              return nearEdgeAcres;
            }
          });
    }
    for (AcreBuilder builder : builders) {
      builder.run(0);
    }
    for (AcreBuilder builder : builders) {
      builder.secondRun().run();
    }
    for (Acre a : acresByID.values()) {
      int c = 0;
      Point p = a.center.toPoint(1000.0);
      for (Sector s : sectors.get()) {
        Acre acre = s.acres.get(p);
        if (acre != null) {
          assert acre == a;
          c++;
        }
      }
      assert a.flavor == Acre.Flavor.MULTI_SECTOR
          ? c >= 5
          : (a.flavor == Acre.Flavor.DUAL_SECTOR ? c == 2 : c == 1);
    }

    if (show.contains("acres")) {
      Set<Long> visitedAcreIds = new HashSet<Long>();
      for (Sector s : sectors.get()) {
        Acre[] acres = s.getInnerAcres();
        for (Acre acre : acres) {
          debugAcre(acre, acre.getIDString(), visitedAcreIds, show, out);
        }
        acres = s.getSharedAcres();
        for (Acre acre : acres) {
          if (acre != null) {
            debugAcre(acre, acre.getIDString(), visitedAcreIds, show, out);
          }
        }
      }
      assert visitedAcreIds.containsAll(acresByID.keySet());
    }
    if (show.contains("neighbors")) {
      double v = 0.7, w = 1.0 - v;
      for (Acre a : acresByID.values()) {
        for (long neighborID : a.neighbors) {
          Acre n = acresByID.get(neighborID);
          if (n != null) {
            Point s = a.center.toPoint(1000.0);
            Point t = n.center.toPoint(1000.0);
            out.addArrow(
                Color.white,
                s.x * v + t.x * w,
                s.z * v + t.z * w,
                s.x * w + t.x * v,
                s.z * w + t.z * v);
          }
        }
      }
    }
  }
Ejemplo n.º 4
0
 private int addNeighbors(
     Acre[] acresA, int rowA, int lengthA, Acre[] acresB, int rowB, int lengthB) {
   if (lengthA <= 0 || lengthB <= 0) {
     return 0; // no-op
   }
   if (lengthB > lengthA) {
     int t = rowA;
     rowA = rowB;
     rowB = t;
     t = lengthA;
     lengthA = lengthB;
     lengthB = t;
   }
   if (lengthA == lengthB) {
     for (int i = 0; i < lengthA; i++) {
       Acre acreA = acresA[rowA + i];
       Acre acreB = acresB[rowB + i];
       acreA.addNeighbor(acreB, indexOfMyNeighbor(acreA, acreB));
       acreB.addNeighbor(acreA, indexOfMyNeighbor(acreB, acreA));
     }
     return lengthA * 2;
   } else {
     assert lengthA <= lengthB + 2;
     if (lengthA == lengthB + 1) {
       for (int i = 0; i < lengthB; i++) {
         Acre acreA = acresA[rowA + i];
         Acre acreB = acresB[rowB + i];
         Acre acreC = acresA[rowA + i + 1];
         acreA.addNeighbor(acreB, indexOfMyNeighbor(acreA, acreB));
         acreB.addNeighbor(acreA, indexOfMyNeighbor(acreB, acreA));
         acreB.addNeighbor(acreC, indexOfMyNeighbor(acreB, acreC));
         acreC.addNeighbor(acreB, indexOfMyNeighbor(acreC, acreB));
       }
       return lengthB * 4;
     } else {
       for (int i = 0; i < lengthB; i++) {
         Acre acreA = acresA[rowA + i + 1];
         Acre acreB = acresB[rowB + i];
         acreA.addNeighbor(acreB, indexOfMyNeighbor(acreA, acreB));
         acreB.addNeighbor(acreA, indexOfMyNeighbor(acreB, acreA));
       }
       return lengthB * 4;
     }
   }
 }
Ejemplo n.º 5
0
 private static void debugAcre(
     Acre a, String label, Set<Long> visitedAcreIds, Set<String> show, OutputGraph out) {
   if (visitedAcreIds != null) {
     visitedAcreIds.add(a.id);
   }
   double x = 0, y = 0;
   int l = a.points.length;
   double[] coords = new double[l * 2 + 2];
   for (int j = 0; j <= l; j++) {
     Point p = a.points[j % l].toPoint(1000.0);
     coords[j * 2] = p.x;
     coords[j * 2 + 1] = p.z;
     if (j < l) {
       x += p.x;
       y += p.z;
     }
   }
   x /= l;
   y /= l;
   for (int j = 0; j <= l; j++) {
     coords[j * 2] = coords[j * 2] * 0.85 + x * 0.15;
     coords[j * 2 + 1] = coords[j * 2 + 1] * 0.85 + y * 0.15;
   }
   if (label == null) {
     out.addLine(Color.white, coords);
   } else {
     Color polyColor, textColor = Color.black;
     AbstractCartographicElement parent = a.getParent();
     boolean inverted = parent instanceof Sector && ((Sector) parent).isInverted();
     int neighbors = 0;
     for (long id : a.neighbors) {
       if (id != 0) {
         neighbors++;
       }
     }
     switch (a.flavor) {
       case INNER1:
         polyColor = inverted ? Color.green : Color.red;
         break;
       case INNER2:
         polyColor = inverted ? Color.red : Color.green;
         break;
       case INNER3:
         //                    polyColor = Color.blue;
         //                    break;
       case DUAL_SECTOR:
         polyColor = new Color(51, 51, 255);
         break;
       case MULTI_SECTOR:
         polyColor = Color.gray.brighter();
         textColor = Color.black;
         break;
       default:
         polyColor = Color.black;
         textColor = Color.red;
         break;
     }
     if (neighbors < 6) {
       polyColor = polyColor.darker().darker();
       if (textColor == Color.black) {
         textColor = Color.white;
       }
       out.addPoly(polyColor, coords);
       double[] closed = new double[coords.length + 2];
       System.arraycopy(coords, 0, closed, 0, coords.length);
       System.arraycopy(coords, 0, closed, coords.length, 2);
       out.addLine(polyColor, closed);
     } else {
       out.addPoly(polyColor, coords);
     }
     if (show.contains("labels")) {
       if (label.contains("~")) {
         Matcher matcher = Pattern.compile("^(.*):\\[(.*)~(.*)]$").matcher(label);
         matcher.find();
         out.addLabel(
             textColor,
             matcher.group(1) + "\n" + matcher.group(2) + "\n" + matcher.group(3),
             x,
             y);
       } else {
         Matcher matcher = Pattern.compile("^(.*?):(.*)$").matcher(label);
         matcher.find();
         out.addLabel(textColor, matcher.group(1) + "\n" + matcher.group(2), x, y);
       }
     }
   }
 }