Beispiel #1
0
 public AIWorld(World gameWorld) {
   synchronized (gameWorld) {
     movementGraph = GraphGenerator.generateGraph(gameWorld);
   }
   logger.info(
       "Initialized graph with "
           + movementGraph.edgeSet().size()
           + " edges and "
           + movementGraph.vertexSet().size()
           + " vertices");
   world = new World(new Vector2(), true);
   PhysicsHelper.createLoaderBodies(
       world, Gdx.files.internal("data/world/world.json"), "strategicPoints");
   strategicPoints = GraphGenerator.generateStrategicPoints(world);
   logger.info("Loaded ai world and found " + strategicPoints.size() + " strategic points");
   createGraphVisible();
   EventManager.addListener(EventEnum.PARSER_AI_GRAPH_VISIBLE, this);
 }
  /**
   * Links all the spots in the selection, in time-forward order.
   *
   * @param model the model to modify.
   * @param selectionModel the selection that contains the spots to link.
   */
  public static void linkSpots(final Model model, final SelectionModel selectionModel) {

    /*
     * Configure tracker
     */

    final TrackableObjectCollection<Spot> spots =
        new DefaultTOCollection<Spot>(selectionModel.getSpotSelection());
    final Map<String, Object> settings = new HashMap<String, Object>(1);
    settings.put(KEY_LINKING_MAX_DISTANCE, Double.POSITIVE_INFINITY);
    final NearestNeighborTracker<Spot> tracker = new NearestNeighborTracker<Spot>(spots, settings);
    tracker.setNumThreads(1);

    /*
     * Execute tracking
     */

    if (!tracker.checkInput() || !tracker.process()) {
      System.err.println("Problem while computing spot links: " + tracker.getErrorMessage());
      return;
    }
    final SimpleWeightedGraph<Spot, DefaultWeightedEdge> graph = tracker.getResult();

    /*
     * Copy found links in source model
     */

    model.beginUpdate();
    try {
      for (final DefaultWeightedEdge edge : graph.edgeSet()) {
        final Spot source = graph.getEdgeSource(edge);
        final Spot target = graph.getEdgeTarget(edge);
        model.addEdge(source, target, graph.getEdgeWeight(edge));
      }
    } finally {
      model.endUpdate();
    }
  }
Beispiel #3
0
 private void createGraphVisible() {
   if (graphVisibleBodies == null) graphVisibleBodies = new ArrayList<Body>();
   for (int i = 0; i < graphVisibleBodies.size(); i++)
     world.destroyBody(graphVisibleBodies.get(i));
   graphVisibleBodies.clear();
   if (nodesVisible)
     for (Vector2 node : movementGraph.vertexSet())
       PhysicsHelper.createCircle(world, BodyType.StaticBody, .1f, 1, FactionType.NEUTRAL)
           .setTransform(node, 0);
   if (edgesVisible)
     for (DefaultWeightedEdge edge : movementGraph.edgeSet()) {
       Vector2 source = movementGraph.getEdgeSource(edge),
           target = movementGraph.getEdgeTarget(edge);
       PhysicsHelper.createEdge(
           world,
           BodyType.StaticBody,
           source.x,
           source.y,
           target.x,
           target.y,
           1,
           FactionType.NEUTRAL);
     }
 }
Beispiel #4
0
  public static void main(String[] args) throws IOException {
    System.out.println("Enter parameters: N p_w p_r steps:");
    try {
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
      String paras[] = reader.readLine().split(" ");
      N = Integer.parseInt(paras[0]);
      p_w = Float.parseFloat(paras[1]);
      p_r = Float.parseFloat(paras[2]);
      steps = Integer.parseInt(paras[3]);
    } catch (IOException e) {
      System.out.println("Error reading from user");
    }

    long start = System.currentTimeMillis();

    int simulations = 1;
    for (int t = 1; t <= simulations; t++) {

      // Initialization, generate an empty network of N nodes
      EIM dynamic = new EIM();
      G = new SimpleWeightedGraph<Integer, DefaultWeightedEdge>(DefaultWeightedEdge.class);
      for (int i = 0; i < N; i++) G.addVertex(i);
      String para = "EIM_" + Integer.toString(t);
      String folder = "files/" + "Networks" + "/";
      File f = new File(folder);
      if (f.exists() == false) {
        f.mkdirs();
      }

      // distribution of social space
      socialposition = dynamic.uniform(N);

      for (int s = 0; s < steps; s++) {
        int v = random.nextInt(N);
        // LA process - weighted random walk + link with social distance
        dynamic.localattach(v);
        // GA process
        // no edges, create one random link
        if (G.edgesOf(v).size() == 0) {
          dynamic.globalattach(v);
        } else {
          float prob = random.nextFloat();
          if (prob < p_r) dynamic.globalattach(v);
        }
        // ND process
        int d = random.nextInt(N);
        if (G.edgesOf(d).size() > 0) {
          float prob = random.nextFloat();
          if (prob < p_d) {
            Set<DefaultWeightedEdge> edges = new HashSet(G.edgesOf(d));
            G.removeAllEdges(edges);
          }
        }
        if (s % 100000 == 0) {
          System.out.print("Steps:" + Integer.toString(s) + "	");
          System.out.print("Edges:");
          System.out.print(G.edgeSet().size() + "	");
          System.out.println(
              "Avg_degree: "
                  + Float.toString((float) G.edgeSet().size() * 2 / G.vertexSet().size()));
        }
      }
      // delete isolate nodes
      ArrayList<Integer> nodelist = new ArrayList<Integer>();
      for (int node : G.vertexSet()) nodelist.add(node);
      for (int node : nodelist) {
        if (G.degreeOf(node) == 0) G.removeVertex(node);
      }
      System.out.print("Nodes:");
      System.out.println(G.vertexSet().size());
      System.out.print("Edges:");
      System.out.println(G.edgeSet().size());

      // get largest connected component
      Statistics stat = new Statistics();
      Graph G_LCC = stat.largestConnectedComponent(G);

      ExportGraph export = new ExportGraph();
      export.exportWPairs((SimpleWeightedGraph<Integer, DefaultWeightedEdge>) G_LCC, para, folder);
      System.out.print("Nodes in LCC:");
      System.out.println(G_LCC.vertexSet().size());
      System.out.print("Edges in LCC:");
      System.out.println(G_LCC.edgeSet().size());
      System.out.println("Avg_degree: " + Double.toString(stat.avg_degree(G_LCC)));
      System.out.println("Avg_clustering: " + Double.toString(stat.avg_clustering(G_LCC)));
      System.out.println(
          "Degree assortativity: " + Double.toString(stat.assortativityCoefficient(G_LCC)));
    }

    long elapsedTimeMillis = System.currentTimeMillis() - start;
    float elapsedTimeHour = elapsedTimeMillis / (60 * 60 * 1000F);
    System.out.print("Elapsed time: ");
    System.out.print(elapsedTimeHour);
    System.out.println(" hours.");
  }
  public EdgeBetweennessGraph(WeightedMultigraph<String, DefaultWeightedEdge> originalGraph) {
    super(DefaultWeightedEdge.class); // Constructor inherented from parent class

    // 1. Initialize the edge betweenness digraph
    // 1.1. Add vertices
    for (String thisVertex : originalGraph.vertexSet()) this.addVertex(thisVertex);
    // 1.2. Add edges
    for (DefaultWeightedEdge thisEdge : originalGraph.edgeSet()) {
      DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
      String sendingName = originalGraph.getEdgeSource(thisEdge);
      String receivingName = originalGraph.getEdgeTarget(thisEdge);
      this.addEdge(sendingName, receivingName, newEdge);
      this.setEdgeWeight(newEdge, 0.0);
    }
    // 1.3. Create corresponding unweighted graph
    // 1.3.1. Add vertices
    WeightedMultigraph<String, DefaultWeightedEdge> originalUnweightedGraph =
        new WeightedMultigraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class);
    for (String thisVertex : originalGraph.vertexSet())
      originalUnweightedGraph.addVertex(thisVertex);
    // 1.3.2. Add edges
    for (DefaultWeightedEdge thisEdge : originalGraph.edgeSet()) {
      DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
      String sendingName = originalGraph.getEdgeSource(thisEdge);
      String receivingName = originalGraph.getEdgeTarget(thisEdge);
      originalUnweightedGraph.addEdge(sendingName, receivingName, newEdge);
      originalUnweightedGraph.setEdgeWeight(newEdge, 1.0);
    }

    for (String thisVertex : this.vertexSet()) {
      // 2. Create shortest-path graph for every vertex by Dijkstra algorithm
      Multigraph<String, DefaultEdge> shortestPathDigraph =
          DijkstraAlgorithm(originalUnweightedGraph, thisVertex);

      // 3. Calculate the contribution of current vertex's shortest-path graph to final edge
      // betweenness (Newman algorithm)
      SimpleWeightedGraph<String, DefaultWeightedEdge> edgeBetweennessDigraph =
          NewmanAlgorithm(shortestPathDigraph, thisVertex);

      // 4. Update final edge betweenness digraph with current vertex's shortest-path graph
      if (edgeBetweennessDigraph != null)
        for (DefaultWeightedEdge thisEdge : edgeBetweennessDigraph.edgeSet()) {
          String sourceVertex = edgeBetweennessDigraph.getEdgeSource(thisEdge);
          String targetVertex = edgeBetweennessDigraph.getEdgeTarget(thisEdge);
          double betweennessWeight = edgeBetweennessDigraph.getEdgeWeight(thisEdge);
          DefaultWeightedEdge edgeInWholeGraph = this.getEdge(sourceVertex, targetVertex);
          double newWeight = this.getEdgeWeight(edgeInWholeGraph) + betweennessWeight;
          this.setEdgeWeight(edgeInWholeGraph, newWeight);
        }
    }

    // 5. Revise the edge betweenness digraph with the original active power digraph
    for (DefaultWeightedEdge thisEdge : this.edgeSet()) {
      String sourceVertex = this.getEdgeSource(thisEdge);
      String targetVertex = this.getEdgeTarget(thisEdge);
      double betweennessWeight = this.getEdgeWeight(thisEdge);
      DefaultWeightedEdge edgeInWholeGraph = originalGraph.getEdge(sourceVertex, targetVertex);
      double newWeight = betweennessWeight / originalGraph.getEdgeWeight(edgeInWholeGraph);
      this.setEdgeWeight(thisEdge, newWeight);
      //			System.out.println("Final edge betweenness between " + sourceVertex + " and " +
      // targetVertex + ": " + newWeight);
    }
  }
  // Create shortest-path graph for every vertex by depth-first traversal algorithm
  private Multigraph<String, DefaultEdge> DijkstraAlgorithm(
      WeightedMultigraph<String, DefaultWeightedEdge> originalGraph, String thisVertex) {

    // 1. Simplify the multi-graph of the active power flow into a simple graph
    SimpleWeightedGraph<String, DefaultWeightedEdge> originalSimpleGraph =
        new SimpleWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class);
    for (String curVertex : originalGraph.vertexSet()) originalSimpleGraph.addVertex(curVertex);
    for (DefaultWeightedEdge curEdge : originalGraph.edgeSet()) {
      String sourceVertex = originalGraph.getEdgeSource(curEdge);
      String targetVertex = originalGraph.getEdgeTarget(curEdge);
      if (originalSimpleGraph.containsEdge(sourceVertex, targetVertex)) {
        DefaultWeightedEdge modifiedEdge = originalSimpleGraph.getEdge(sourceVertex, targetVertex);
        double newEdgeWeight =
            originalSimpleGraph.getEdgeWeight(modifiedEdge) + originalGraph.getEdgeWeight(curEdge);
        originalSimpleGraph.setEdgeWeight(modifiedEdge, newEdgeWeight);
      } else {
        DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
        originalSimpleGraph.addEdge(sourceVertex, targetVertex, newEdge);
        originalSimpleGraph.setEdgeWeight(newEdge, originalGraph.getEdgeWeight(curEdge));
      }
    }
    // Issue (2010/10/25): Maybe larger amount of active power transfer still means weaker
    // relationship between the two terminal buses of a certain branch,
    // thus originalSimpleGraph other than inverseGraph should be used here.
    // Use the inverse of active power to build a new weighted directed graph (the larger the active
    // power is, the close the two buses will be)
    //		SimpleDirectedWeightedGraph<String, DefaultWeightedEdge> inverseGraph =
    //			new SimpleDirectedWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class);
    //		for (String curVertex : originalSimpleGraph.vertexSet())
    //			inverseGraph.addVertex(curVertex);
    //		for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgeSet()) {
    //			String sourceVertex = originalSimpleGraph.getEdgeSource(curEdge);
    //			String targetVertex = originalSimpleGraph.getEdgeTarget(curEdge);
    //			DefaultWeightedEdge newEdge = new DefaultWeightedEdge();
    //			inverseGraph.addEdge(sourceVertex, targetVertex, newEdge);
    //			inverseGraph.setEdgeWeight(newEdge, 1 / originalSimpleGraph.getEdgeWeight(curEdge));
    //		}
    // 2. Initialize the map of vertices and the corresponding weights (distance from current vertex
    // to the first vertex)
    HashMap<String, Double> mapVertexShortestDistance = new HashMap<String, Double>();
    //		for (String thisOriginalVertex : inverseGraph.vertexSet())
    for (String thisOriginalVertex : originalSimpleGraph.vertexSet())
      mapVertexShortestDistance.put(thisOriginalVertex, 10E10);
    // The weight of the first vertex is zero
    mapVertexShortestDistance.put(thisVertex, 0.0);

    // 3. Depth-first traversing, update the shortest-path values
    Stack<String> bfiVertices =
        new Stack<String>(); // Stack to store passed vertices in a breadth-first traversing
    // The map of a weighted edge and the flag of having been visited
    //		HashMap<DefaultWeightedEdge, Boolean> mapEdgeVisited = new HashMap<DefaultWeightedEdge,
    // Boolean>();
    //		for (DefaultWeightedEdge thisEdge : inverseGraph.edgeSet())
    //			mapEdgeVisited.put(thisEdge, false);
    String currentVertex = thisVertex;
    bfiVertices.push(currentVertex);
    //		System.out.println(bfiVertices.toString());
    while (!bfiVertices.isEmpty()) {
      // Operate the following codes for those edges started with current vertex
      boolean hasNewEdge = false;
      //			for (DefaultWeightedEdge curEdge : inverseGraph.outgoingEdgesOf(currentVertex)) {
      for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgesOf(currentVertex)) {
        //				if (!mapEdgeVisited.get(curEdge)) {	// Used for those edges that have not been treated
        // yet
        // 3.1. Mark current edge as already been visited
        //					mapEdgeVisited.put(curEdge, true);
        //				String nextVertex = inverseGraph.getEdgeTarget(curEdge);
        String nextVertex = originalSimpleGraph.getEdgeTarget(curEdge);
        // 3.2. Update shortest-path values
        double curSD = mapVertexShortestDistance.get(currentVertex);
        //					double edgeWeight = inverseGraph.getEdgeWeight(curEdge);
        double edgeWeight = originalSimpleGraph.getEdgeWeight(curEdge);
        double newSD = curSD + edgeWeight;
        if (mapVertexShortestDistance.get(nextVertex) > newSD) {
          hasNewEdge = true;
          mapVertexShortestDistance.put(nextVertex, newSD);
          // 3.3. Push the target vertex of current edge into the stack
          bfiVertices.push(nextVertex);
          //						System.out.println(bfiVertices.toString());
          break;
          //						System.out.println("New shortest path [" + nextVertex + "]: " + newSD);
        }
        //				}
      }
      if (!hasNewEdge) {
        bfiVertices.pop();
      }
      if (!bfiVertices.isEmpty()) currentVertex = bfiVertices.peek();
    }
    // 4. Create shortest-path digraph of current vertex
    // 4.1. Initialize the shortest-path digraph
    Multigraph<String, DefaultEdge> shortestPathGraph =
        new Multigraph<String, DefaultEdge>(DefaultEdge.class);
    // 4.2. Add all qualified edges
    //		for (DefaultWeightedEdge curEdge : inverseGraph.edgeSet()) {
    for (DefaultWeightedEdge curEdge : originalSimpleGraph.edgeSet()) {
      // 4.2.1. Evaluate if current edge is suitable
      //			String sourceVertex = inverseGraph.getEdgeSource(curEdge);
      //			String targetVertex = inverseGraph.getEdgeTarget(curEdge);
      String sourceVertex = originalSimpleGraph.getEdgeSource(curEdge);
      String targetVertex = originalSimpleGraph.getEdgeTarget(curEdge);
      //			if (Math.abs(inverseGraph.getEdgeWeight(curEdge) -
      if (originalSimpleGraph.getEdgeWeight(curEdge) > 1.0E-5) {
        if (Math.abs(
                originalSimpleGraph.getEdgeWeight(curEdge)
                    - (mapVertexShortestDistance.get(targetVertex)
                        - mapVertexShortestDistance.get(sourceVertex)))
            < 1.0E-5) {
          // 4.2.2. Add suitable edge that found just now
          DefaultEdge newEdge = new DefaultEdge();
          if (!shortestPathGraph.containsVertex(sourceVertex))
            shortestPathGraph.addVertex(sourceVertex);
          if (!shortestPathGraph.containsVertex(targetVertex))
            shortestPathGraph.addVertex(targetVertex);
          shortestPathGraph.addEdge(sourceVertex, targetVertex, newEdge);
        }
      }
    }
    return shortestPathGraph;
  }