コード例 #1
0
 @Override
 public void run(TaskMonitor taskMonitor) throws Exception {
   JAXBContext jaxbContext =
       JAXBContext.newInstance(CYTABLES_PACKAGE, getClass().getClassLoader());
   taskMonitor.setProgress(0.33);
   Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
   taskMonitor.setProgress(0.67);
   cyTables = (CyTables) unmarshaller.unmarshal(inputStream);
   taskMonitor.setProgress(1);
 }
コード例 #2
0
  @Override
  public void run(TaskMonitor taskMonitor) throws Exception {
    if (network == null) network = appMgr.getCurrentNetwork();
    views = new ArrayList<CyNetworkView>(viewMgr.getNetworkViews(network));

    taskMonitor.showMessage(
        TaskMonitor.Level.INFO, "Views for network " + DataUtils.getNetworkTitle(network));
    for (CyNetworkView view : views) {
      taskMonitor.showMessage(TaskMonitor.Level.INFO, "    " + view);
      return;
    }
  }
コード例 #3
0
    @Override
    public void run(TaskMonitor monitor) throws Exception {
      monitor.setStatusMessage("Executing ForceAtlas2 layout");

      List<ExtensionCall> calls = exec.buildExtensionCalls();

      double progress = 0.0;
      for (ExtensionCall call : calls) {
        Object callRetValue = plugin.getInteractor().executeExtensionCall(call, false);
        exec.processCallResponse(call, callRetValue);
        ++progress;
        monitor.setProgress(progress / ((double) calls.size()));
      }
    }
コード例 #4
0
  @Override
  public void run(TaskMonitor taskMonitor) throws Exception {
    taskMonitor.setTitle("Loading Gene Association File");
    taskMonitor.setStatusMessage("Importing annotation file.  Please wait...");
    taskMonitor.setProgress(-1.0);

    this.ontologyDAG = OntologyDAGManager.getOntologyDAG(ontologyDagName);

    if (ontologyDAG == null) logger.warn("Could not find associated Ontology DAG.");
    else {
      termIDList =
          ontologyDAG.getDefaultNodeTable().getColumn(CyNetwork.NAME).getValues(String.class);
    }

    BufferedReader bufRd =
        new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8").newDecoder()));
    String line = null;
    String[] parts;

    while ((line = bufRd.readLine()) != null) {
      // Validate.
      if (line.contains(COMPATIBLE_VERSION)) break;
    }

    // Create result table
    table =
        serviceRegistrar
            .getService(CyTableFactory.class)
            .createTable(tableName, CyNetwork.NAME, String.class, true, true);
    createColumns();

    while ((line = bufRd.readLine()) != null) {
      if (line.startsWith("!")) continue;

      parts = line.split(GA_DELIMITER);
      // GA is a fixed format file. Read only valid lines.
      if (parts.length >= EXPECTED_COL_COUNT) {
        parseGA(parts);
      }
    }

    bufRd.close();
    is.close();
    is = null;

    tables = new CyTable[1];
    tables[0] = table;

    serviceRegistrar.getService(CyTableManager.class).addTable(table);
  }
コード例 #5
0
  private void loadNetwork(TaskMonitor tm) throws IOException {
    final CyNetwork network = this.rootNetwork.addSubNetwork();
    tm.setProgress(0.10);
    this.reader.setNetwork(network);

    if (this.cancelled) return;

    this.reader.read();
    tm.setProgress(0.80);

    if (this.cancelled) return;

    networks = new CyNetwork[] {network};
    tm.setProgress(1.0);
  }
コード例 #6
0
  /**
   * 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());
  }
コード例 #7
0
  @Override
  public void run(TaskMonitor tm) throws Exception {
    tm.setTitle("Loading network from table");
    tm.setProgress(0.0);
    tm.setStatusMessage("Loading network...");

    Workbook workbook = null;

    // Load Spreadsheet data for preview.
    if (fileType != null
        && (fileType.equalsIgnoreCase(SupportedFileType.EXCEL.getExtension())
            || fileType.equalsIgnoreCase(SupportedFileType.OOXML.getExtension()))
        && workbook == null) {
      try {
        workbook = WorkbookFactory.create(is);
      } catch (InvalidFormatException e) {
        throw new IllegalArgumentException(
            "Could not read Excel file.  Maybe the file is broken?", e);
      } finally {
        if (is != null) is.close();
      }
    }

    try {
      if (this.fileType.equalsIgnoreCase(SupportedFileType.EXCEL.getExtension())
          || this.fileType.equalsIgnoreCase(SupportedFileType.OOXML.getExtension())) {
        String networkName = ntmp.getName();

        if (networkName == null) networkName = workbook.getSheetName(0);

        final Sheet sheet = workbook.getSheet(networkName);

        reader =
            new ExcelNetworkSheetReader(
                networkName, sheet, ntmp, nMap, rootNetwork, serviceRegistrar);
      } else {
        reader = new NetworkTableReader(inputName, is, ntmp, nMap, rootNetwork, serviceRegistrar);
      }
    } catch (Exception ioe) {
      tm.showMessage(TaskMonitor.Level.ERROR, "Unable to read table: " + ioe.getMessage());
      return;
    }

    loadNetwork(tm);
    tm.setProgress(1.0);
  }
コード例 #8
0
  @Override
  public void run(TaskMonitor taskMonitor) throws Exception {

    taskMonitor.setTitle("Updating Organism Interactome Data Files");
    taskMonitor.setProgress(-1);
    taskMonitor.setStatusMessage("Downloading data from BioGRID...");

    BiogridDataLoader task = new BiogridDataLoader(props, dataSource, settingFileLocation);
    task.extract(true);

    final String version = task.getVersion();

    taskMonitor.setProgress(1.0d);
    taskMonitor.setStatusMessage(
        "Organism network data files has been updated to BioGRID version "
            + version
            + ".  Please restart Cytoscape to use new data.");
  }
コード例 #9
0
  /** Executes Task. */
  public void run(TaskMonitor taskMonitor) throws Exception {
    taskMonitor.setTitle("Loading Network");
    taskMonitor.setProgress(0);
    taskMonitor.setStatusMessage("Reading in Network Data...");

    try {
      CyNetworkReaderManager readerManager = factory.getCyNetworkViewReaderManager();
      CyNetworkReader reader = readerManager.getReader(url.toURI(), url.getFile());

      if (reader == null) {
        JOptionPane.showMessageDialog(
            factory.getCySwingApplication().getJFrame(),
            "Unable to connect to URL " + url,
            "URL Connect Error",
            JOptionPane.ERROR_MESSAGE);
        return;
      }
      taskMonitor.setStatusMessage("Creating Cytoscape Network...");
      reader.run(taskMonitor);
      CyNetwork[] networks = reader.getNetworks();
      CyNetwork cyNetwork = networks[0];

      // TODO: Does CPath2 listen for this?
      //			Object[] ret_val = new Object[2];
      //			ret_val[0] = cyNetwork;
      //			ret_val[1] = url.toString();
      //
      //			Cytoscape.firePropertyChange(Cytoscape.NETWORK_LOADED, null, ret_val);

      if (cyNetwork != null) {
        informUserOfGraphStats(cyNetwork, taskMonitor);
      } else {
        StringBuffer sb = new StringBuffer();
        sb.append("Could not read network from: ");
        sb.append(url);
        sb.append("\nThis file may not be a valid file format.");
        throw new IOException(sb.toString());
      }
      taskMonitor.setProgress(1.0);
    } catch (Exception e) {
      throw new Exception("Unable to load network.", e);
    }
  }
コード例 #10
0
 @Override
 public void run(TaskMonitor monitor) throws Exception {
   // TODO Auto-generated method stub
   monitor.setTitle("Building the User Interface");
   DynNetworkView<T> view = dynNetViewManager.getDynNetworkView(cyNetworkView);
   DynNetwork<T> dynamicnetwork = view.getNetwork();
   GraphMetricsPanel<T, C> graphMetricsPanel =
       new GraphMetricsPanel<T, C>(this.cyActivator, dynamicnetwork);
   this.cyActivator
       .getCyServiceRegistrar()
       .registerService(graphMetricsPanel, CytoPanelComponent.class, new Properties());
 }
コード例 #11
0
  @Override
  public CyNetworkView buildCyNetworkView(final CyNetwork network) {
    final CyNetworkView view = networkViewFactory.createNetworkView(network);
    final CyLayoutAlgorithm layout = layouts.getDefaultLayout();
    TaskIterator itr =
        layout.createTaskIterator(
            view, layout.getDefaultLayoutContext(), CyLayoutAlgorithm.ALL_NODE_VIEWS, "");
    Task nextTask = itr.next();
    try {
      nextTask.run(parentTaskMonitor);
    } catch (Exception e) {
      throw new RuntimeException("Could not finish layout", e);
    }

    parentTaskMonitor.setProgress(1.0d);
    return view;
  }
コード例 #12
0
  @Override
  public void run(final TaskMonitor taskMonitor) {
    taskMonitor.setTitle("Adding variations...");
    taskMonitor.setProgress(0.0d);

    if (!mergeStrategy.isRetain()) {
      final Lock nodesReadLock = model.nodes().getReadWriteLock().readLock();
      final Lock featuresReadLock = model.features().getReadWriteLock().readLock();
      final Lock variationsWriteLock = model.variations().getReadWriteLock().writeLock();
      nodesReadLock.lock();
      featuresReadLock.lock();
      variationsWriteLock.lock();
      try {
        for (int i = 0, size = model.features().size(); i < size; i++) {
          Feature feature = model.features().get(i);
          taskMonitor.setStatusMessage(
              "Retrieving variations associated with feature " + feature + "...");
          final List<Variation> variations = model.getVariationService().variations(feature);
          taskMonitor.setStatusMessage(
              resultStatusMessage(variations.size(), "variation", "feature", feature));

          // todo:  merge strategy
          for (Variation variation : variations) {
            if (!model.variations().contains(variation)) {
              model.variations().add(variation);
            }
          }

          // todo:  count doesn't consider existing variations
          for (CyNode node : model.nodesFor(feature)) {
            addCount(node, model.getNetwork(), "variation_count", variations.size());
          }
          taskMonitor.setProgress(i / (double) size);
        }
      } finally {
        nodesReadLock.unlock();
        featuresReadLock.unlock();
        variationsWriteLock.unlock();
      }
    }
    taskMonitor.setProgress(1.0d);
  }
コード例 #13
0
  @Override
  public void run(TaskMonitor taskMonitor) throws Exception {
    parentTaskMonitor = taskMonitor;
    long start = System.currentTimeMillis();

    taskMonitor.setProgress(0.01d);
    taskMonitor.setTitle("Loading PSI-MI 2.5.x XML File ");
    taskMonitor.setStatusMessage("Loading data file in PSI-MI 2.5 XML format.");

    // support to add network into existing collection
    this.initNodeMap();

    PsimiXmlReader reader = new PsimiXmlReader();
    EntrySet result = reader.read(inputStream);
    taskMonitor.setProgress(0.4d);
    taskMonitor.setStatusMessage("Data Loaded.  Mapping Data to Network...");

    if (cancelFlag) {
      inputStream.close();
      reader = null;
      result = null;
      return;
    }

    // network = cyNetworkFactory.createNetwork();
    String networkCollectionName = this.rootNetworkList.getSelectedValue().toString();
    if (networkCollectionName.equalsIgnoreCase(CRERATE_NEW_COLLECTION_STRING)) {
      // This is a new network collection, create a root network and a subnetwork, which is a base
      // subnetwork
      network = cyNetworkFactory.createNetwork();
    } else {
      // Add a new subNetwork to the given collection
      network = this.name2RootMap.get(networkCollectionName).addSubNetwork();
    }

    mapper = new PSIMI25EntryMapper(network, result);
    mapper.map();

    taskMonitor.setProgress(1.0d);
    logger.info(
        "PSI-MI XML Data Import finihsed in " + (System.currentTimeMillis() - start) + " msec.");
  }
コード例 #14
0
  @Override
  protected void complete(TaskMonitor tm) throws Exception {
    tm.setProgress(0.4);
    tm.setTitle("Set network tables");
    tm.setStatusMessage("Setting network tables...");
    mergeNetworkTables();

    tm.setProgress(0.5);
    tm.setTitle("Restore virtual columns");
    tm.setStatusMessage("Restoring virtual columns...");
    restoreVirtualColumns();

    tm.setProgress(0.6);
    tm.setTitle("Extract network views");
    tm.setStatusMessage("Extracting network views...");
    // Read the session file again, this time to extract the network views
    networksExtracted = true;
    readSessionFile(tm);

    tm.setProgress(0.8);
    tm.setTitle("Update SUID columns");
    tm.setStatusMessage("Updating SUID columns...");
    updateSUIDColumns();

    super.complete(tm);
  }
コード例 #15
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
コード例 #16
0
  public void run(TaskMonitor monitor) {
    monitor.setTitle("Performing MCL cluster");
    this.monitor = monitor;
    if (network == null) network = clusterManager.getNetwork();

    context.setNetwork(network);

    NodeCluster.init();

    DistanceMatrix matrix = context.edgeAttributeHandler.getMatrix();
    if (matrix == null) {
      monitor.showMessage(
          TaskMonitor.Level.ERROR, "Can't get distance matrix: no attribute value?");
      return;
    }

    // Update our tunable results
    clusterAttributeName = context.getClusterAttribute();
    createGroups = context.advancedAttributes.createGroups;

    if (canceled) return;

    // Cluster the nodes
    runMCL =
        new RunMCL(
            matrix,
            context.inflation_parameter,
            context.iterations,
            context.clusteringThresh,
            context.maxResidual,
            context.maxThreads,
            monitor);

    runMCL.setDebug(debug);

    if (canceled) return;

    monitor.showMessage(TaskMonitor.Level.INFO, "Clustering...");

    // results = runMCL.run(monitor);
    List<NodeCluster> clusters = runMCL.run(network, monitor);
    if (clusters == null) return; // Canceled?

    monitor.showMessage(TaskMonitor.Level.INFO, "Removing groups");

    // Remove any leftover groups from previous runs
    removeGroups(network, GROUP_ATTRIBUTE);

    monitor.showMessage(TaskMonitor.Level.INFO, "Creating groups");

    params = new ArrayList<String>();
    context.edgeAttributeHandler.setParams(params);

    List<List<CyNode>> nodeClusters = createGroups(network, clusters, GROUP_ATTRIBUTE);

    results = new AbstractClusterResults(network, nodeClusters);

    monitor.showMessage(TaskMonitor.Level.INFO, "MCL results:\n" + results);

    if (context.vizProperties.showUI) {
      monitor.showMessage(TaskMonitor.Level.INFO, "Creating network");
      insertTasksAfterCurrentTask(
          new NewNetworkView(network, clusterManager, true, context.vizProperties.restoreEdges));
    }
  }
コード例 #17
0
ファイル: PR.java プロジェクト: nrnb/clusterMaker2
  @Override
  public void run(TaskMonitor taskMonitor) {
    taskMonitor.setProgress(0.0);
    taskMonitor.setTitle("PRWP with Priors ranking of clusters");
    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Fetching clusters...");
    taskMonitor.setProgress(0.1);
    List<NodeCluster> clusters = ClusterUtils.fetchClusters(network);
    taskMonitor.setProgress(0.5);

    initVariables();
    clusters.forEach(NodeCluster::initNodeScores);

    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Setting node scores in clusters");
    addNodes();
    taskMonitor.setProgress(0.6);

    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Setting edge scores in clusters");
    addEdges();
    taskMonitor.setProgress(0.7);

    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Calculating PageRank scores");
    PageRank<PRNode, PREdge> pageRank = performPageRank();
    taskMonitor.setProgress(0.8);

    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Inserting scores into clusters");
    insertScores(clusters, pageRank);
    taskMonitor.setProgress(0.9);

    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Insert cluster information in tables");
    ClusterUtils.insertResultsInColumns(network, clusters, SHORTNAME);

    taskMonitor.setProgress(1.0);
    taskMonitor.showMessage(TaskMonitor.Level.INFO, "Done...");
  }
    @Override
    public void run(TaskMonitor taskMonitor) throws Exception {
      CaseList caseList = (CaseList) caseSetComboBox.getSelectedItem();
      Object[] profiles = profileList.getSelectedValues();
      String geneSymbolField = (String) geneSymbolComboBox.getSelectedItem();
      // update the configuration to store this field
      MondrianApp app = MondrianApp.getInstance();
      CyNetwork currentNetwork = app.getAppManager().getCurrentNetwork();

      // call the next two lines in the right order!
      app.getMondrianConfiguration()
          .setNetworkGeneSymbolAttr(currentNetwork.getSUID(), geneSymbolField);
      Map<String, Long> geneSymbolMap =
          app.getMondrianConfiguration().getGeneNodeMap(currentNetwork.getSUID());

      List<String> genes = new ArrayList<String>(geneSymbolMap.keySet());

      // Extract data from web service
      int p = 1;
      List<GeneticProfile> profileList = new ArrayList<GeneticProfile>();
      List<MondrianCyTable> importedTables = new ArrayList<MondrianCyTable>();
      CyNetwork network = app.getAppManager().getCurrentNetwork();
      CancerStudy study = (CancerStudy) cancerStudyComboBox.getSelectedItem();
      for (Object obj : profiles) {
        GeneticProfile profile = (GeneticProfile) obj;
        profileList.add(profile);
        taskMonitor.setStatusMessage("Loading genetic profile: " + profile.getName());
        taskMonitor.setProgress(p++ / (double) profiles.length);

        CyTable table =
            MondrianApp.getInstance()
                .getTableFactory()
                .createTable(profile.getName(), CyIdentifiable.SUID, Long.class, true, true);
        DataTypeMatrix matrix = portalClient.getProfileData(caseList, profile, genes);

        List<String> dataColNames = matrix.getDataColNames();
        for (String colName : dataColNames) {
          if (profile.getType() == GENETIC_PROFILE_TYPE.MUTATION_EXTENDED) {
            table.createColumn(colName, String.class, false);
          } else {
            table.createColumn(colName, Double.class, false);
          }
        }

        // Add rows
        for (String rowName : matrix.getRowNames()) {
          long suid = geneSymbolMap.get(rowName);
          CyRow row = table.getRow(suid);
          // row.set("selected", currentNetwork.getDefaultNodeTable().getRow(suid).get("selected",
          // Boolean.class));
          // row.set(geneSymbolField, rowName);
          int i = 0;
          for (String colName : dataColNames) {
            row.set(colName, matrix.getDataRow(rowName).get(i++));
          }
        }
        log.debug(
            "Loading genetic profile: "
                + profile.getName()
                + "; Insert Table: "
                + matrix.getNumRows()
                + ", "
                + matrix.getDataColNames().size());

        MondrianCyTable mondrianCyTable = new MondrianCyTable(study, profile, caseList, table);
        importedTables.add(mondrianCyTable);
        //
      }
      app.getMondrianConfiguration().registerMondrianTables(network, importedTables);
      // app.getMondrianConfiguration().cbioDataImport(currentNetwork.getSUID(), profileList,
      // caseList);
    }
コード例 #19
0
 public void run(TaskMonitor taskMonitor) throws Exception {
   taskMonitor.setTitle("Exiting Chimera");
   structureManager.exitChimera();
 }
コード例 #20
0
  @Override
  public void run(TaskMonitor taskMonitor) throws Exception {
    desktopApp.getJFrame().getGlassPane().setVisible(true);
    taskMonitor.setTitle("Gene Set / Mutation Analysis");
    taskMonitor.setStatusMessage("Loading file...");
    taskMonitor.setProgress(.25d);
    try {
      Map<String, Integer> geneToSampleNumber = null;
      Map<String, String> geneToSampleString = null;
      Map<String, Set<String>> sampleToGenes = null;
      Set<String> selectedGenes = null;

      if (format.equals("MAF")) {

        sampleToGenes =
            new MATFileLoader().loadSampleToGenes(file.getAbsolutePath(), chooseHomoGenes);
        selectedGenes =
            CancerAnalysisUtilitites.selectGenesInSamples(sampleCutoffValue, sampleToGenes);
      } else if (format.equals("GeneSample")) {
        geneToSampleNumber = new HashMap<String, Integer>();
        geneToSampleString = new HashMap<String, String>();
        loadGeneSampleFile(file, geneToSampleNumber, geneToSampleString);
        selectedGenes = selectGenesBasedOnSampleCutoff(geneToSampleNumber, sampleCutoffValue);
      } else if (format.equals("GeneSet")) {
        selectedGenes = loadGeneSetFile(file);
      }
      // Check if it is possible to construct the network
      // given the sample size.
      if (useLinkers) {
        taskMonitor.setStatusMessage("Checking FI Network size...");
        FINetworkService fiService = PlugInScopeObjectManager.getManager().getNetworkService();
        Integer cutoff = fiService.getNetworkBuildSizeCutoff();
        if (cutoff != null && selectedGenes.size() >= cutoff) {
          JOptionPane.showMessageDialog(
              desktopApp.getJFrame(),
              "The size of the gene set is too big. Linker genes should not be used!\n"
                  + "Please try again without using linker genes.",
              "Error in Building Network",
              JOptionPane.ERROR_MESSAGE);
          desktopApp.getJFrame().getGlassPane().setVisible(false);
          return;
        }
      }

      CytoPanel controlPane = desktopApp.getCytoPanel(CytoPanelName.WEST);
      int selectedIndex = controlPane.getSelectedIndex();
      taskMonitor.setStatusMessage("Constructing FI Network...");
      taskMonitor.setProgress(.50d);
      CyNetwork network = constructFINetwork(selectedGenes, file.getName());
      network.getDefaultNetworkTable().getRow(network.getSUID()).set("name", file.getName());
      if (network == null) {
        JOptionPane.showMessageDialog(
            desktopApp.getJFrame(),
            "Cannot find any functional interaction among provided genes.\n"
                + "No network can be constructed.\n"
                + "Note: only human gene names are supported.",
            "Empty Network",
            JOptionPane.INFORMATION_MESSAGE);
        desktopApp.getJFrame().getGlassPane().setVisible(false);
        return;
      }
      netManager.addNetwork(network);

      // Fix for missing default value persistence in CyTables
      // Should be remedied in the 3.1 api
      CyTable nodeTable = network.getDefaultNodeTable();
      for (Object name : network.getNodeList()) {
        CyNode node = (CyNode) name;
        Long nodeSUID = node.getSUID();
        nodeTable.getRow(nodeSUID).set("isLinker", false);
      }

      controlPane.setSelectedIndex(selectedIndex);
      if (sampleToGenes != null) {
        geneToSampleNumber = new HashMap<String, Integer>();
        geneToSampleString = new HashMap<String, String>();
        Map<String, Set<String>> geneToSamples =
            InteractionUtilities.switchKeyValues(sampleToGenes);
        geneToSamples.keySet().retainAll(selectedGenes);
        for (String gene : geneToSamples.keySet()) {
          Set<String> samples = geneToSamples.get(gene);
          geneToSampleNumber.put(gene, samples.size());
          geneToSampleString.put(gene, InteractionUtilities.joinStringElements(";", samples));
        }
      }
      taskMonitor.setStatusMessage("Formatting network attributes...");
      taskMonitor.setProgress(.65d);
      CyTableManager tableManager = new CyTableManager();
      CyNetworkView view = viewFactory.createNetworkView(network);
      tableManager.storeFINetworkVersion(view);
      tableManager.storeDataSetType(network, CyTableFormatter.getSampleMutationData());
      viewManager.addNetworkView(view);
      if (geneToSampleNumber != null && !geneToSampleNumber.isEmpty()) {
        tableManager.loadNodeAttributesByName(view, "sampleNumber", geneToSampleNumber);
      }
      if (geneToSampleString != null && !geneToSampleString.isEmpty()) {
        tableManager.loadNodeAttributesByName(view, "samples", geneToSampleString);
      }
      // Check if linker genes are to be used.
      if (useLinkers) {
        taskMonitor.setStatusMessage("Fetching linker genes...");
        Map<String, Boolean> geneToIsLinker = new HashMap<String, Boolean>();
        for (Object name : network.getNodeList()) {
          CyNode node = (CyNode) name;
          Long suid = node.getSUID();
          String nodeName = network.getDefaultNodeTable().getRow(suid).get("name", String.class);
          geneToIsLinker.put(nodeName, !selectedGenes.contains(nodeName));
        }
        tableManager.loadNodeAttributesByName(view, "isLinker", geneToIsLinker);
      }
      if (fetchFIAnnotations) {
        taskMonitor.setStatusMessage("Fetching FI annotations...");
        new FIAnnotationHelper().annotateFIs(view, new RESTFulFIService(), tableManager);
      }
      if (view.getModel().getEdgeCount() != 0) {
        for (CyEdge edge : view.getModel().getEdgeList()) {
          tableManager.storeEdgeName(edge, view);
        }
      }
      BundleContext context = PlugInScopeObjectManager.getManager().getBundleContext();
      ServiceReference visHelperRef = context.getServiceReference(FIVisualStyle.class.getName());
      if (visHelperRef != null) {
        FIVisualStyleImpl styleHelper = (FIVisualStyleImpl) context.getService(visHelperRef);
        styleHelper.setVisualStyle(view);
        styleHelper.setLayout();
      }
      //            BundleContext context =
      // PlugInScopeObjectManager.getManager().getBundleContext();
      //            ServiceReference styleHelperRef =
      // context.getServiceReference(FIVisualStyleImpl.class.getName());
      //            FIVisualStyleImpl styleHelper = (FIVisualStyleImpl)
      // context.getService(styleHelperRef);

      taskMonitor.setProgress(1.0d);
    } catch (Exception e) {
      JOptionPane.showMessageDialog(
          desktopApp.getJFrame(),
          "Error in Loading File: " + e.getMessage(),
          "Error in Loading",
          JOptionPane.ERROR_MESSAGE);
      desktopApp.getJFrame().getGlassPane().setVisible(false);
    }
    desktopApp.getJFrame().getGlassPane().setVisible(false);
  }
コード例 #21
0
  private void readInput(TaskMonitor tm) throws IOException {
    this.parentTaskMonitor = tm;
    tm.setProgress(0.0);

    String line;
    final BufferedReader br =
        new BufferedReader(
            new InputStreamReader(inputStream, Charset.forName("UTF-8").newDecoder()), 128 * 1024);

    String networkCollectionName = this.rootNetworkList.getSelectedValue().toString();

    CySubNetwork subNetwork;
    if (networkCollectionName.equalsIgnoreCase(CRERATE_NEW_COLLECTION_STRING)) {
      // This is a new network collection, create a root network and a subnetwork, which is a base
      // subnetwork
      CyNetwork rootNetwork = cyNetworkFactory.createNetwork();
      subNetwork = this.cyRootNetworkManager.getRootNetwork(rootNetwork).addSubNetwork();
    } else {
      // Add a new subNetwork to the given collection
      subNetwork = this.name2RootMap.get(networkCollectionName).addSubNetwork();
    }

    // Build a Map based on the key attribute for the entire collection,
    // For SIF network, the 'shared name' attribute is the primary key
    this.initNodeMap(subNetwork.getRootNetwork(), "shared " + CyNetwork.NAME);

    tm.setProgress(0.1);

    // Generate bundled event to avoid too many events problem.

    final String firstLine = br.readLine();
    if (firstLine.contains(TAB)) delimiter = TAB;
    createEdge(new Interaction(firstLine.trim(), delimiter), subNetwork);

    tm.setProgress(0.15);
    tm.setStatusMessage("Processing the interactions...");
    int numInteractionsRead = 0;
    while ((line = br.readLine()) != null) {
      if (cancelled) {
        // Cancel called. Clean up the garbage.
        nMap.clear();
        nMap = null;
        subNetwork = null;
        br.close();
        return;
      }

      if (line.trim().length() <= 0) continue;

      try {
        final Interaction itr = new Interaction(line, delimiter);
        createEdge(itr, subNetwork);
      } catch (Exception e) {
        // Simply ignore invalid lines.
        continue;
      }

      if ((++numInteractionsRead % 1000) == 0)
        tm.setStatusMessage("Processed " + numInteractionsRead + " interactions so far.");
    }

    br.close();
    tm.setStatusMessage("Processed " + numInteractionsRead + " interactions in total.");

    nMap.clear();
    nMap = null;

    this.cyNetworks = new CyNetwork[] {subNetwork};

    tm.setProgress(1.0);

    logger.debug("SIF file loaded: ID = " + subNetwork.getSUID());
  }
コード例 #22
0
  @SuppressWarnings("unchecked")
  @Override
  protected void doLayout(TaskMonitor taskMonitor) {
    if (!context.m_cancel && networkView != null && dynView != null) {
      taskMonitor.setTitle("Compute Dynamic Kamada Kawai Force Layout");
      taskMonitor.setStatusMessage("Running energy minimization...");
      taskMonitor.setProgress(0);

      // int size = (int) (4*50*Math.sqrt(nodesToLayOut.size()));

      int size =
          (int)
              (dynView.getCurrentVisualStyle().getDefaultValue(BasicVisualLexicon.NODE_SIZE)
                  * Math.sqrt(nodesToLayOut.size()));
      // int size =(int)
      // dynView.getCurrentVisualStyle().getDefaultValue(BasicVisualLexicon.NETWORK_HEIGHT).floatValue();

      snap = new DynNetworkSnapshotImpl<T>(dynView, context.m_attribute_name);
      kklayout = new KKLayout<T>(snap, new Dimension(4 * size, 4 * size));
      List<Double> events = context.m_event_list;

      // Full KK evaluation to initialize the network at time t=0
      kklayout.setAdjustForGravity(true);
      kklayout.setExchangeVertices(context.m_exchange_nodes);
      kklayout.setAutoscaling(context.m_autoscale);
      kklayout.setMaxIterations(1000);

      // Compute incremental KK. The number of iterations is proportional to the time to the next
      // event.
      double t0, t1;
      for (int t = 0; t < events.size() - 1; t++) {
        t0 = events.get(Math.max(0, t - context.m_past_events));
        t1 = events.get(Math.min(events.size() - 1, t + 1 + context.m_future_events));

        snap.setInterval((DynInterval<T>) new DynIntervalDouble(t0, t1), t, 1000, 1000);
        if (!context.m_attribute_name.equals("none"))
          kklayout.setDistance(new DijkstraShortestPath<T>(snap, snap.getWeightMap(), 100));
        else kklayout.setDistance(new UnweightedShortestPath<T>(snap));

        kklayout.initialize();
        kklayout.run();
        updateGraph((DynInterval<T>) new DynIntervalDouble(events.get(t), events.get(t + 1)));
        kklayout.setMaxIterations(
            (int) (context.m_iteration_rate * (events.get(t + 1) - events.get(t))));

        if (t % 10 == 0) taskMonitor.setProgress(((double) t) / (double) events.size());

        taskMonitor.setStatusMessage("Running energy minimization... " + t + "/" + events.size());
      }

      // Finalize layout
      layout.finalize();
      taskMonitor.setProgress(1);

      // Set the current network view
      initializePositions(size);
      layout.initNodePositions(timeInterval);
      view.fitContent();
      view.updateView();
    }
  }