protected CyNode getNodeByName(CyNetwork net, String name) {
    for (CyNode n : net.getNodeList()) {
      if (name.equals(net.getRow(n).get(NAME, String.class))) return n;
    }

    return null;
  }
  protected CyEdge getEdgeByName(CyNetwork net, String name) {
    for (CyEdge e : net.getEdgeList()) {
      if (name.equals(net.getRow(e).get(NAME, String.class))) return e;
    }

    return null;
  }
  /**
   * Inform User of Network Stats.
   *
   * @param taskMonitor
   */
  private void informUserOfGraphStats(CyNetwork newNetwork, TaskMonitor taskMonitor) {
    NumberFormat formatter = new DecimalFormat("#,###,###");
    StringBuffer sb = new StringBuffer();

    // Give the user some confirmation
    sb.append("Successfully loaded network from:  ");
    sb.append(url);
    sb.append("\n\nNetwork contains " + formatter.format(newNetwork.getNodeCount()));
    sb.append(" nodes and " + formatter.format(newNetwork.getEdgeCount()));
    sb.append(" edges.\n\n");

    // TODO: Port this
    //		if (newNetwork.getNodeCount() < Integer.parseInt(CytoscapeInit.getProperties()
    //
    // .getProperty("viewThreshold"))) {
    //			sb.append("Network is under "
    //			          + CytoscapeInit.getProperties().getProperty("viewThreshold")
    //			          + " nodes.  A view will be automatically created.");
    //		} else {
    //			sb.append("Network is over "
    //			          + CytoscapeInit.getProperties().getProperty("viewThreshold")
    //			          + " nodes.  A view has not been created."
    //			          + "  If you wish to view this network, use "
    //			          + "\"Create View\" from the \"Edit\" menu.");
    //		}
    taskMonitor.setStatusMessage(sb.toString());
  }
  private List<String> getAttributeList(
      CyNetwork network,
      Set<Class<?>> allowedNodeAttributeTypes,
      Set<Class<?>> allowedEdgeAttributeTypes) {
    List<String> attributes = new ArrayList<String>();
    Set<Class<?>> allowedTypes;
    CyTable table;
    if (allowedNodeAttributeTypes.size() > 0) {
      allowedTypes = allowedNodeAttributeTypes;
      table = network.getDefaultNodeTable();
    } else if (allowedEdgeAttributeTypes.size() > 0) {
      allowedTypes = allowedEdgeAttributeTypes;
      table = network.getDefaultEdgeTable();
    } else {
      return attributes;
    }

    for (final CyColumn column : table.getColumns()) {
      if (allowedTypes.contains(column.getType())) {
        attributes.add(column.getName());
      }
    }

    if (attributes.size() > 0) attributes.add(0, UNWEIGHTED);
    return attributes;
  }
  /** all lines have the degenerate form "node1" that is, with no interaction type and no target */
  @Test
  public void testReadFileWithNoInteractions() throws Exception {
    List<CyNetworkView> views = getViews("degenerate.sif");
    CyNetwork net = checkSingleNetwork(views, 9, 0);

    for (CyNode n : net.getNodeList())
      assertTrue(net.getRow(n).get("name", String.class).startsWith("Y"));
  }
  private boolean hasSelectedNodes(final CyNetworkView view) {
    if (view == null) return false;

    final CyNetwork network = view.getModel();
    final CyTable table = network.getDefaultNodeTable();

    return table.countMatchingRows(CyNetwork.SELECTED, Boolean.TRUE) > 0;
  }
Exemple #7
0
  private void initVariables() {
    edgeAttributes = context.getSelectedEdgeAttributes();

    graph = new DirectedSparseMultigraph<>();
    idToNode = new HashMap<>();
    nodeList = network.getNodeList();
    edgeList = network.getEdgeList();
    nodeTable = network.getDefaultNodeTable();
    edgeTable = network.getDefaultEdgeTable();
  }
  private void display() {

    CyServiceRegistrarImpl register = new CyServiceRegistrarImpl(bc);

    CyNetworkViewManager viewManager = register.getService(CyNetworkViewManager.class);
    CyNetworkViewFactory viewFactory = register.getService(CyNetworkViewFactory.class);
    CyNetworkView networkView = viewFactory.createNetworkView(network);
    viewManager.addNetworkView(networkView);

    VisualMappingFunctionFactory passthroughFactory =
        register.getService(VisualMappingFunctionFactory.class, "(mapping.type=passthrough)");
    VisualMappingFunctionFactory continuousFactory =
        register.getService(VisualMappingFunctionFactory.class, "(mapping.type=continuous)");
    VisualMappingManager vmManager = register.getService(VisualMappingManager.class);
    VisualStyleFactory vsFactory = register.getService(VisualStyleFactory.class);
    VisualStyle vs =
        vsFactory.createVisualStyle(
            network.getDefaultNetworkTable().getRow(network.getSUID()).get("name", String.class));

    PassthroughMapping pMapping =
        (PassthroughMapping)
            passthroughFactory.createVisualMappingFunction(
                "name", String.class, BasicVisualLexicon.NODE_LABEL);

    vs.addVisualMappingFunction(pMapping);
    vs.apply(networkView);

    ContinuousMapping mapping =
        (ContinuousMapping)
            continuousFactory.createVisualMappingFunction(
                "score", Double.class, BasicVisualLexicon.NODE_FILL_COLOR);

    Double val1 = getMinimum(network.getDefaultNodeTable().getColumn("score"));
    BoundaryRangeValues<Paint> brv1 =
        new BoundaryRangeValues<Paint>(Color.GREEN, Color.GREEN, Color.GREEN);

    Double val3 = getMaximum(network.getDefaultNodeTable().getColumn("score"));
    BoundaryRangeValues<Paint> brv3 =
        new BoundaryRangeValues<Paint>(Color.RED, Color.RED, Color.RED);

    Double val2 = (val1 + val3 + val1 + val1) / 4;
    BoundaryRangeValues<Paint> brv2 =
        new BoundaryRangeValues<Paint>(Color.YELLOW, Color.YELLOW, Color.YELLOW);

    mapping.addPoint(val1, brv1);
    mapping.addPoint(val2, brv2);
    mapping.addPoint(val3, brv3);

    vs.addVisualMappingFunction(mapping);
    vs.apply(networkView);

    vmManager.addVisualStyle(vs);
    vmManager.setVisualStyle(vs, networkView);
    networkView.updateView();
  }
 @Test
 public void testRemoveNodeIndexStaysConstant() {
   assertEquals(0, net.getNodeCount());
   CyNode n0 = net.addNode();
   CyNode n1 = net.addNode();
   long n0i = n0.getSUID();
   long n1i = n1.getSUID();
   net.removeNodes(Collections.singletonList(n0));
   long nnli = n1.getSUID();
   assertEquals(nnli, n1i);
 }
 @Inject
 public CreateThematicMapDialog(
     CySwingApplication application, CyApplicationManager applicationManager) {
   super(application.getJFrame(), true);
   CyNetwork inputNetwork = applicationManager.getCurrentNetwork();
   this.networkName = inputNetwork.getRow(inputNetwork).get(CyNetwork.NAME, String.class);
   setTitle("Create Thematic Map: " + networkName);
   this.applicationManager = applicationManager;
   createContents();
   updateEnablement();
 }
  /**
   * @param args the function arguments which must be either one object of type Double or Long
   * @return the result of the function evaluation which is the natural logarithm of the first
   *     argument
   */
  public Object evaluateFunction(final Object[] args) {
    final Long edgeID = FunctionUtil.getArgAsLong(args[0]);

    final CyNetwork currentNetwork = applicationManager.getCurrentNetwork();
    if (currentNetwork == null) return (Long) (-1L);

    final CyEdge edge = currentNetwork.getEdge(edgeID);
    if (edge == null)
      throw new IllegalArgumentException("\"" + edgeID + "\" is not a valid edge identifier.");

    return edge.getSource().getSUID();
  }
  /** Assuming we only create one network. */
  protected CyNetwork checkSingleNetwork(List<CyNetworkView> views, int numNodes, int numEdges) {
    assertNotNull(views);
    assertEquals(1, views.size());

    CyNetwork net = views.get(0).getModel();

    assertNotNull(net);

    assertEquals(numNodes, net.getNodeCount());
    assertEquals(numEdges, net.getEdgeCount());

    return net;
  }
 private Set<View<CyNode>> getLayoutNodes(CyLayoutAlgorithm layout, CyNetworkView networkView) {
   if (layout.getSupportsSelectedOnly() && selectedTunable.selectedNodesOnly) {
     Set<View<CyNode>> nodeViews = new HashSet<View<CyNode>>();
     CyNetwork network = networkView.getModel();
     for (View<CyNode> view : networkView.getNodeViews()) {
       if (network.getRow(view.getModel()).get(CyNetwork.SELECTED, Boolean.class)
           && view.getVisualProperty(BasicVisualLexicon.NODE_VISIBLE)) {
         nodeViews.add(view);
       }
     }
     return nodeViews;
   }
   return CyLayoutAlgorithm.ALL_NODE_VIEWS;
 }
Exemple #14
0
 protected final CyNode getNode(final CyNetwork network, final Long nodeId) {
   final CyNode node = network.getNode(nodeId);
   if (node == null) {
     throw new NotFoundException("Could not find node with SUID: " + nodeId);
   }
   return node;
 }
  public boolean isReady(CyNetwork network) {
    if (scope == Scope.ALLNODES && settings.hasNodeCompounds(network.getNodeList())) return true;

    if (scope == Scope.SELECTEDNODES) return selectedNodesReady(network);

    return false;
  }
  private void extractNetworks(InputStream is, String entryName) throws Exception {
    CyNetworkReader reader = networkReaderMgr.getReader(is, entryName);
    reader.run(taskMonitor);
    final CyNetwork[] netArray = reader.getNetworks();

    for (final CyNetwork net : netArray) {
      // Add its root-network to the lookup map first
      final CyRootNetwork rootNet = rootNetworkManager.getRootNetwork(net);

      if (!networkLookup.containsKey(rootNet.getSUID())) ;
      networkLookup.put(rootNet.getSUID(), rootNet);

      networkLookup.put(net.getSUID(), net);
      networks.add(net); // Note: do NOT add the root-network to this set!
    }
  }
  /** Add any nodes that are above the neighbor threshold to our cluster */
  public NodeCluster doFilter(List<CyNode> nodeList, Map<NodeCluster, List<CyNode>> addedNodeMap) {
    Set<CyNode> clusterNodes = new HashSet<CyNode>(nodeList);
    List<CyNode> newNodeList = new ArrayList<CyNode>();
    newNodeList.addAll(nodeList);
    List<CyNode> nodesToAdd = new ArrayList<CyNode>();
    for (CyNode node : nodeList) {
      for (CyNode neighbor : network.getNeighborList(node, CyEdge.Type.ANY)) {
        if (clusterNodes.contains(neighbor)) continue;
        double adjacency = getAdjacency(neighbor, clusterNodes);
        if (adjacency > context.threshold) {
          // Add this node to our list
          nodesToAdd.add(neighbor);
        }
      }
    }

    newNodeList.addAll(nodesToAdd);

    if (newNodeList.size() > 1) {
      NodeCluster newNodeCluster = new NodeCluster(newNodeList);
      if (nodesToAdd.size() > 0) addedNodeMap.put(newNodeCluster, nodesToAdd);
      return newNodeCluster;
    }
    return null;
  }
 @Test
 public void testGetIndex() {
   CyNode n1 = net.addNode();
   CyNode n2 = net.addNode();
   assertTrue("index >= 0", n1.getSUID() >= 0);
   assertTrue("index >= 0", n2.getSUID() >= 0);
 }
 // self nested networks are allowed
 @Test
 public void testSetSelfNestedNetwork() {
   CyNode n1 = net.addNode();
   n1.setNetworkPointer(net);
   assertNotNull(n1.getNetworkPointer());
   assertEquals(net, n1.getNetworkPointer());
 }
 @Test
 public void testSetNestedNetwork() {
   CyNode n1 = net.addNode();
   CyNetwork net2 = mock(CyNetwork.class);
   n1.setNetworkPointer(net2);
   assertNotNull(n1.getNetworkPointer());
   assertEquals(net2, n1.getNetworkPointer());
 }
  /**
   * Sets the given AnnotationSet as the "selected" one. If null is passed then all AnnotationSets
   * will be unselected.
   *
   * <p>Note: Currently switching selection is not supported when the currently selected
   * AnnotationSet has collapsed clusters. It is the responsibility of the UI to expand all the
   * clusters before switching the AnnotationSet.
   *
   * <p>MKTODO: It would be better for the model to handle expanding the clusters, but for now we
   * will force the UI to do it.
   *
   * @throws IllegalStateException If the currently active AnnotationSet has collapsed clusters.
   */
  public void select(AnnotationSet annotationSet) {
    if (annotationSet == null || annotationSets.contains(annotationSet)) {

      if (Optional.ofNullable(annotationSet).equals(activeSet)) {
        return;
      }

      if (activeSet.map(AnnotationSet::hasCollapsedCluster).orElse(false)) {
        throw new IllegalStateException("Current AnnotationSet has collapsed clusters");
      }

      CyNetwork network = networkView.getModel();
      activeSet = Optional.ofNullable(annotationSet);

      // ModelManager.handle(AboutToRemoveNodesEvent) only removes nodes from the active annotation
      // set.
      // When switching to a new annotation set we need to "fix" the clusters to remove any nodes
      // that
      // were deleted previously.
      // MKTODO: probably need to test for deleted nodes when serializing the model

      if (annotationSet != null) {
        Set<Cluster> clusters = annotationSet.getClusters();
        for (Cluster cluster :
            new HashSet<>(
                clusters)) { // avoid ConcurrentModificationException because removeNodes() can call
          // delete()
          Set<CyNode> nodesToRemove =
              cluster
                  .getNodes()
                  .stream()
                  .filter(node -> !network.containsNode(node))
                  .collect(Collectors.toSet());

          // Fires ClusterChangedEvent, UI listeners should test if the cluster is part of the
          // active annotation set.
          if (!nodesToRemove.isEmpty()) {
            cluster.removeNodes(nodesToRemove);
          }
        }
      }

      parent.postEvent(new ModelEvents.AnnotationSetSelected(this, activeSet));
    }
  }
 public boolean initWeights() {
   weights = new ArrayList<Double>(edges.size());
   for (int i = 0; i < edges.size(); i++) {
     Double weight = net.getRow(edges.get(i)).get(influenceAttr, Double.class);
     if (weight != null) weights.add(weight);
     else return false;
   }
   return true;
 }
  /** {@inheritDoc} */
  @Override
  public void mapToTable(Graph graph, Edge edge, Evidence evidence, CyTable table) {
    if (graph == null) throw new NullPointerException("graph cannot be null");
    if (edge == null) throw new NullPointerException("edge cannot be null");
    if (evidence == null) throw new NullPointerException("evidence cannot be null");
    if (table == null) throw new NullPointerException("table cannot be null");
    if (graph.cyNetwork == null)
      throw new IllegalArgumentException("graph's cyNetwork cannot be null");
    if (edge.cyEdge == null) throw new IllegalArgumentException("edge's cyEdge cannot be null");

    CyNetwork cyN = graph.cyNetwork;
    CyEdge cyE = edge.cyEdge;

    CyRow networkRow = cyN.getRow(cyN);
    String networkName = networkRow.get(CyNetwork.NAME, String.class);
    CyRow row = table.getRow(SUIDFactory.getNextSUID());

    row.set(NETWORK_SUID, cyN.getSUID());
    row.set(NETWORK_NAME, networkName);
    row.set(EDGE_SUID, cyE.getSUID());
    row.set(BEL_STATEMENT, evidence.belStatement);
    row.set(SUMMARY_TEXT, evidence.summaryText);

    if (evidence.citation != null) {
      row.set(CITATION_TYPE, evidence.citation.type);
      row.set(CITATION_ID, evidence.citation.id);
      row.set(CITATION_NAME, evidence.citation.name);
    }

    if (evidence.biologicalContext != null) {
      // create any annotation columns that do not already exist
      BiologicalContext bc = evidence.biologicalContext;
      for (String varyingKey : bc.variedAnnotations.keySet()) {
        getOrCreateColumn(varyingKey, String.class, false, table);
      }

      // set annotation values
      row.set(SPECIES, bc.speciesCommonName);
      Map<String, Object> varying = bc.variedAnnotations;
      for (Entry<String, Object> entry : varying.entrySet()) {
        row.set(entry.getKey(), getOrEmptyString(entry.getKey(), varying));
      }
    }
  }
 public TaskIterator createTaskIterator(CyNetwork network) {
   if (scope == Scope.ALLNODES)
     return new TaskIterator(
         new SMARTSSearchTask(network, network.getNodeList(), scope, showResult, settings));
   else {
     List<CyNode> selectedNodes = CyTableUtil.getNodesInState(network, CyNetwork.SELECTED, true);
     return new TaskIterator(
         new SMARTSSearchTask(network, selectedNodes, scope, showResult, settings));
   }
 }
 private String convertToName(final String id) {
   final Collection<CyRow> rows =
       ontologyDAG.getDefaultNodeTable().getMatchingRows(CyNetwork.NAME, id);
   if (!rows.isEmpty()) {
     final CyRow row = rows.iterator().next();
     final String termName = row.get(OBOReader.TERM_NAME, String.class);
     if (termName != null) return termName;
     else return id;
   } else return id;
 }
  private Collection<String> getAttributes(boolean node) {
    CyNetwork network = applicationManager.getCurrentNetwork();
    CyTable table = node ? network.getDefaultNodeTable() : network.getDefaultEdgeTable();
    Collection<CyColumn> columns = table.getColumns();

    Set<String> attributes =
        new TreeSet<String>(
            new Comparator<String>() {
              public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);
              }
            });

    for (CyColumn column : columns) {
      if (!CyIdentifiable.SUID.equals(column.getName())
          && (node || Number.class.isAssignableFrom(column.getType()))) {
        attributes.add(column.getName());
      }
    }
    return attributes;
  }
Exemple #27
0
  protected final String getGraphObject(final CyNetwork network, final CyIdentifiable obj) {
    final CyRow row = network.getRow(obj);

    try {
      return this.serializer.serializeGraphObject(obj, row);
    } catch (IOException e) {
      throw getError(
          "Could not serialize graph object with SUID: " + obj.getSUID(),
          e,
          Response.Status.INTERNAL_SERVER_ERROR);
    }
  }
  /** Will fail if it doesn't find the specified interaction. */
  protected void findInteraction(
      CyNetwork net, String source, String target, String interaction, int count) {
    for (CyNode n : net.getNodeList()) {
      String sname = net.getRow(n).get(CyNetwork.NAME, String.class);
      assertNotNull("Source name is NULL", sname);

      if (source.equals(sname)) {
        List<CyNode> neigh = net.getNeighborList(n, CyEdge.Type.ANY);
        assertEquals("wrong number of neighbors", count, neigh.size());

        for (CyNode nn : neigh) {
          String tname = net.getRow(nn).get(CyNetwork.NAME, String.class);
          assertNotNull("Target name is NULL", tname);

          if (tname.equals(target)) {
            List<CyEdge> con = net.getConnectingEdgeList(n, nn, CyEdge.Type.ANY);
            assertTrue("Connecting edge list is empty", con.size() > 0);

            for (CyEdge e : con) {
              String inter = net.getRow(e).get(CyEdge.INTERACTION, String.class);
              assertNotNull("Edge interaction is NULL", inter);

              if (inter.equals(interaction)) {
                return;
              }
            }
          }
        }
      }
    }
    fail("couldn't find interaction: " + source + " " + interaction + " " + target);
  }
 /**
  * Save node attributes computed by NetworkAnalyzer for this network into a tab-delimited file
  * with extension "nattributes" (1st column corresponds to the node ids, each subsequent column
  * contains the values of a node attribute).
  *
  * @param aNetwork Target network.
  * @param aDir Flag indicating if the network interpretation is directed.
  * @param aOutputDir Output directory for writing files as chosen by the user.
  * @param aExtendedName Name of the analyzed network including the current interpretation.
  * @return <code>true</code> if any node attributes where present and have been saved, and <code>
  *     false</code> otherwise.
  */
 private boolean saveNodeAttributes(
     CyNetwork aNetwork, boolean aDir, File aOutputDir, String aExtendedName) {
   // get node attributes computed in the last analysis run
   Set<String> netAnayzerAttr = new HashSet<String>();
   if (aDir) {
     netAnayzerAttr = Messages.getDirNodeAttributes();
   } else {
     netAnayzerAttr = Messages.getUndirNodeAttributes();
   }
   if (netAnayzerAttr.size() == 0) {
     return false;
   }
   // save chosen node attributes in a file, 1st column corresponds to the node ids, each
   // subsequent column
   // contains the values of a node attribute
   try {
     final FileWriter writer = new FileWriter(new File(outputDir, aExtendedName + ".nattributes"));
     writer.write("Node ID");
     for (final String attr : netAnayzerAttr) {
       writer.write("\t" + attr);
     }
     writer.write("\n");
     for (CyNode n : aNetwork.getNodeList()) {
       final String id = aNetwork.getRow(n).get("name", String.class);
       writer.write(id);
       for (final String attr : netAnayzerAttr) {
         final Object attrValue = aNetwork.getRow(n).getRaw(attr);
         if (attrValue != null) {
           writer.write("\t" + attrValue.toString());
         }
       }
       writer.write("\n");
     }
     writer.close();
   } catch (IOException ex) {
     // attributes file could not be written
     return false;
   }
   return true;
 }
  public BellmanFordStatsImpl findPath(
      CyNetwork network, CyNode source, boolean directed, WeightFunction function) {

    Map<CyNode, MetaNode> nodeToMetaNodeMap = new IdentityHashMap<CyNode, MetaNode>();

    boolean negativeCycle = true;

    for (CyNode node : network.getNodeList()) {

      MetaNode metaNode = new MetaNode(node, Double.POSITIVE_INFINITY, null);
      nodeToMetaNodeMap.put(node, metaNode);
    }

    nodeToMetaNodeMap.get(source).setDistance(0.0);

    for (int i = 0; i < network.getNodeCount() - 1; i++) {

      for (CyEdge edge : network.getEdgeList()) {

        MetaNode sourceMetaNode = nodeToMetaNodeMap.get(edge.getSource());
        MetaNode targetMetaNode = nodeToMetaNodeMap.get(edge.getTarget());

        if (targetMetaNode.getDistance()
            > sourceMetaNode.getDistance() + function.getWeight(edge)) {
          targetMetaNode.setDistance(sourceMetaNode.getDistance() + function.getWeight(edge));
          targetMetaNode.setPredecessor(sourceMetaNode.getNode());
        }
      }
    }

    for (CyEdge edge : network.getEdgeList()) {

      MetaNode sourceMetaNode = nodeToMetaNodeMap.get(edge.getSource());
      MetaNode targetMetaNode = nodeToMetaNodeMap.get(edge.getTarget());
      if (targetMetaNode.getDistance() > sourceMetaNode.getDistance() + function.getWeight(edge))
        negativeCycle = false;
    }

    return new BellmanFordStatsImpl(source, nodeToMetaNodeMap, negativeCycle);
  }