コード例 #1
0
  private Collection getNeighbors(CyNode node) {
    Set result = new HashSet();
    Collection edges = network.getAdjacentEdgeList(node, org.cytoscape.model.CyEdge.Type.ANY);
    if (edges == null || edges.size() == 0) return result;
    Long targetID = node.getSUID();
    for (Iterator iterator = edges.iterator(); iterator.hasNext(); ) {
      CyEdge curEdge = (CyEdge) iterator.next();
      if (curEdge.getSource().getSUID() != targetID) result.add(curEdge.getSource());
      else if (curEdge.getTarget().getSUID() != targetID) result.add(curEdge.getTarget());
    }

    return result;
  }
コード例 #2
0
  /**
   * Calculates the node distances.
   *
   * @return the <code>int[][]</code> array of calculated distances or null if the task was canceled
   *     or there was an error
   */
  public int[][] calculate() {
    int currentProgress = 0;
    this.maxValue = distances.length;

    CyNode[] nodes = new CyNode[nodesList.size()];

    // TODO: REMOVE
    // System.err.println( "Calculating all node distances.. for: "
    // +nodesList.size()+" and "+nodes.length );

    // We don't have to make new Integers all the time, so we store the index
    // Objects in this array for reuse.
    Integer[] integers = new Integer[nodes.length];

    // Fill the nodes array with the nodes in their proper index locations.
    // int index;
    CyNode from_node;

    for (int i = 0; i < nodes.length; i++) {

      from_node = (CyNode) nodesList.get(i);
      if (from_node == null) {
        continue;
      }
      int index = ((Integer) nodeIndexToMatrixIndexMap.get(from_node.getSUID())).intValue();
      // index = ((Integer) nodeIndexToMatrixIndexMap.get(new
      // Integer(from_node.getRootGraphIndex()))).intValue();

      if ((index < 0) || (index >= nodes.length)) {
        System.err.println(
            "WARNING: GraphNode \""
                + from_node
                + "\" has an index value that is out of range: "
                + index
                + ".  Graph indices should be maintained such "
                + "that no index is unused.");
        return null;
      }
      if (nodes[index] != null) {
        System.err.println(
            "WARNING: GraphNode \""
                + from_node
                + "\" has an index value ( "
                + index
                + " ) that is the same as "
                + "that of another GraphNode ( \""
                + nodes[index]
                + "\" ).  Graph indices should be maintained such "
                + "that indices are unique.");
        return null;
      }
      nodes[index] = from_node;
      Integer in = new Integer(index);
      integers[index] = in;
    }

    LinkedList queue = new LinkedList();
    boolean[] completed_nodes = new boolean[nodes.length];
    Iterator neighbors;
    CyNode to_node;
    CyNode neighbor;
    int neighbor_index;
    int to_node_distance;
    int neighbor_distance;
    for (int from_node_index = 0; from_node_index < nodes.length; from_node_index++) {

      if (this.interrupted) {
        // The task was canceled
        this.distances = null;
        return this.distances;
      }

      from_node = nodes[from_node_index];

      if (from_node == null) {
        // Make the distances in this row all Integer.MAX_VALUE.
        if (distances[from_node_index] == null) {
          distances[from_node_index] = new int[nodes.length];
        }
        Arrays.fill(distances[from_node_index], Integer.MAX_VALUE);
        continue;
      }

      // TODO: REMOVE
      //  System.err.print( "Calculating node distances from graph node " +
      //                  from_node );
      // System.err.flush();

      // Make the distances row and initialize it.
      if (distances[from_node_index] == null) {
        distances[from_node_index] = new int[nodes.length];
      }
      Arrays.fill(distances[from_node_index], Integer.MAX_VALUE);
      distances[from_node_index][from_node_index] = 0;

      // Reset the completed nodes array.
      Arrays.fill(completed_nodes, false);

      // Add the start node to the queue.
      queue.add(integers[from_node_index]);

      while (!(queue.isEmpty())) {

        if (this.interrupted) {
          // The task was canceled
          this.distances = null;
          return this.distances;
        }

        int index = ((Integer) queue.removeFirst()).intValue();
        if (completed_nodes[index]) {
          continue;
        }
        completed_nodes[index] = true;

        to_node = nodes[index];
        to_node_distance = distances[from_node_index][index];

        if (index < from_node_index) {
          // Oh boy.  We've already got every distance from/to this node.
          int distance_through_to_node;
          for (int i = 0; i < nodes.length; i++) {
            if (distances[index][i] == Integer.MAX_VALUE) {
              continue;
            }
            distance_through_to_node = to_node_distance + distances[index][i];
            if (distance_through_to_node <= distances[from_node_index][i]) {
              // Any immediate neighbor of a node that's already been
              // calculated for that does not already have a shorter path
              // calculated from from_node never will, and is thus complete.
              if (distances[index][i] == 1) {
                completed_nodes[i] = true;
              }
              distances[from_node_index][i] = distance_through_to_node;
            }
          } // End for every node, update the distance using the distance from
          // to_node.
          // So now we don't need to put any neighbors on the queue or
          // anything, since they've already been taken care of by the previous
          // calculation.
          continue;
        } // End if to_node has already had all of its distances calculated.

        neighbors = getNeighbors(to_node).iterator();

        // neighbors = perspective.neighborsList(to_node).iterator();

        while (neighbors.hasNext()) {

          if (this.interrupted) {
            this.distances = null;
            return this.distances;
          }

          neighbor = (CyNode) neighbors.next();

          neighbor_index = ((Integer) nodeIndexToMatrixIndexMap.get(neighbor.getSUID())).intValue();

          // neighbor_index = ((Integer) nodeIndexToMatrixIndexMap.get(new
          // Integer(neighbor.getRootGraphIndex()))).intValue();

          // If this neighbor was not in the incoming List, we cannot include
          // it in any paths.
          if (nodes[neighbor_index] == null) {
            distances[from_node_index][neighbor_index] = Integer.MAX_VALUE;
            continue;
          }

          if (completed_nodes[neighbor_index]) {
            // We've already done everything we can here.
            continue;
          }

          neighbor_distance = distances[from_node_index][neighbor_index];

          if ((to_node_distance != Integer.MAX_VALUE)
              && (neighbor_distance > (to_node_distance + 1))) {
            distances[from_node_index][neighbor_index] = (to_node_distance + 1);
            queue.addLast(integers[neighbor_index]);
          }

          // TODO: REMOVE
          // System.out.print( "." );
          // System.out.flush();

        } // For each of the next nodes' neighbors
        // TODO: REMOVE
        // System.out.print( "|" );
        // System.out.flush();
      } // For each to_node, in order of their (present) distances

      // TODO: REMOVE
      /*
      System.err.println( "done." );
      */
      // Calculate Percentage.  This must be a value between 0..100.
      int percentComplete = (int) (((double) currentProgress / maxValue) * 100);

      //  Estimate Time Remaining
      long timeRemaining = maxValue - currentProgress;

      //  Update the Task Monitor.
      //  This automatically updates the UI Component w/ progress bar.
      if (taskMonitor != null) {
        taskMonitor.setProgress(percentComplete);
        taskMonitor.setStatusMessage(
            "Calculating Node Distances: " + currentProgress + "of " + maxValue);
        // taskMonitor.setEstimatedTimeRemaining(timeRemaining);
      }

      currentProgress++;
    } // For each from_node

    // TODO: REMOVE
    // System.err.println( "..Done calculating all node distances." );

    return distances;
  } // calculate