예제 #1
1
    public void endDocument() throws SAXException {
      // time to actually set up the edges
      IntIterator rows = m_edges.rows();
      while (rows.hasNext()) {
        int r = rows.nextInt();

        String src = m_edges.getString(r, SRCID);
        if (!m_nodeMap.containsKey(src)) {
          throw new SAXException(
              "Tried to create edge with source node id=" + src + " which does not exist.");
        }
        int s = ((Integer) m_nodeMap.get(src)).intValue();
        m_edges.setInt(r, SRC, s);

        String trg = m_edges.getString(r, TRGID);
        if (!m_nodeMap.containsKey(trg)) {
          throw new SAXException(
              "Tried to create edge with target node id=" + trg + " which does not exist.");
        }
        int t = ((Integer) m_nodeMap.get(trg)).intValue();
        m_edges.setInt(r, TRG, t);
      }
      m_edges.removeColumn(SRCID);
      m_edges.removeColumn(TRGID);

      // now create the graph
      m_graph = new Graph(m_nodes, m_edges, m_directed);
      if (m_graphid != null) m_graph.putClientProperty(ID, m_graphid);
    }
예제 #2
0
 /** Initialize mapping between prefuse table rows and the rows reported by this model. */
 private void initRowMap() {
   m_rowmap = new int[m_table.getRowCount()];
   IntIterator rows = m_table.rows();
   for (int i = 0; rows.hasNext(); ++i) {
     m_rowmap[i] = rows.nextInt();
   }
 }
예제 #3
0
  private Table processJournalName(Table table) throws IOException {

    ScimapsJournalMatcher scimapsJournalMatcher = new ScimapsJournalMatcher();

    // Create new output table
    Table outputTable = TableUtilities.copyTable(table);
    outputTable.addColumn(STANDARDIZED_JOURNAL_NAME_COLUMN, String.class);
    int standardizedJournalNameColumnIndex =
        outputTable.getColumnNumber(STANDARDIZED_JOURNAL_NAME_COLUMN);

    // Retrieve iterator
    Iterator<?> rows = outputTable.tuples();

    // Process journal names
    int rowIndex = 0;
    while (rows.hasNext()) {
      Tuple row = (Tuple) rows.next();
      if (row.canGetString(journalColumnName)) {
        String name = row.getString(journalColumnName);
        String suggestedName = scimapsJournalMatcher.get(name);
        outputTable.setString(rowIndex, standardizedJournalNameColumnIndex, suggestedName);
      }
      rowIndex++;
    }
    return outputTable;
  }
예제 #4
0
 private Table createTableSchema(Schema graphSchema, Table t) {
   for (int i = 0; i < graphSchema.getColumnCount(); i++) {
     t.addColumn(graphSchema.getColumnName(i), graphSchema.getColumnType(i));
   }
   t.addColumn(UNIQUE_INDEX_COLUMN_NAME, int.class);
   t.addColumn(COMBINE_VALUES_COLUMN_NAME, String.class, "*");
   return t;
 }
예제 #5
0
    public void startElement(String namespaceURI, String localName, String qName, Attributes atts) {
      // first clear the character buffer
      m_sbuf.delete(0, m_sbuf.length());

      if (qName.equals(GRAPH)) {
        // parse directedness default
        String edef = atts.getValue(EDGEDEF);
        m_directed = DIRECTED.equalsIgnoreCase(edef);
        m_graphid = atts.getValue(ID);
      } else if (qName.equals(KEY)) {
        if (!inSchema) {
          error(
              "\""
                  + KEY
                  + "\" elements can not"
                  + " occur after the first node or edge declaration.");
        }
        m_for = atts.getValue(FOR);
        m_id = atts.getValue(ID);
        m_name = atts.getValue(ATTRNAME);
        m_type = atts.getValue(ATTRTYPE);
      } else if (qName.equals(NODE)) {
        schemaCheck();

        m_row = m_nodes.addRow();

        String id = atts.getValue(ID);
        m_nodeMap.put(id, new Integer(m_row));
        m_table = m_nodes;
      } else if (qName.equals(EDGE)) {
        schemaCheck();

        m_row = m_edges.addRow();

        // do not use the id value
        //                String id = atts.getValue(ID);
        //                if ( id != null ) {
        //                    if ( !m_edges.canGetString(ID) )
        //                        m_edges.addColumn(ID, String.class);
        //                    m_edges.setString(m_row, ID, id);
        //                }
        m_edges.setString(m_row, SRCID, atts.getValue(SRC));
        m_edges.setString(m_row, TRGID, atts.getValue(TRG));

        // currently only global directedness is used
        // ignore directed edge value for now
        //                String dir = atts.getValue(DIRECTED);
        //                boolean d = m_directed;
        //                if ( dir != null ) {
        //                    d = dir.equalsIgnoreCase("false");
        //                }
        //                m_edges.setBoolean(m_row, DIRECTED, d);
        m_table = m_edges;
      } else if (qName.equals(DATA)) {
        m_key = atts.getValue(KEY);
      }
    }
예제 #6
0
 private float compareNodesCaseSensitiveBy(
     String attributeColumn, Integer nodeOneIndex, Integer nodeTwoIndex, Table nodeTable) {
   String nodeOneAttribute =
       (String) nodeTable.getString(nodeOneIndex.intValue(), attributeColumn);
   String nodeTwoAttribute =
       (String) nodeTable.getString(nodeTwoIndex.intValue(), attributeColumn);
   float similarity = this.similarityChecker.getSimilarity(nodeOneAttribute, nodeTwoAttribute);
   return similarity;
 }
예제 #7
0
 private DatabaseTable inferTableToBeMerged(Table mergingTable)
     throws AlgorithmExecutionException {
   String header = mergingTable.getColumnName(mergingTable.getColumnCount() - 1);
   String name = extractNameFromHeader(header);
   try {
     return DatabaseTable.fromRepresentation(name);
   } catch (InvalidRepresentationException e) {
     throw new AlgorithmExecutionException(INVALID_TABLE_NAME_HEADER_MESSAGE);
   }
 }
예제 #8
0
 public static JComponent demo() {
   String datafile = "/amazon.txt";
   Table data = null;
   try {
     data = (new DelimitedTextTableReader()).readTable(datafile);
     data.addColumn("image", "CONCAT('/images/',id,'.01.MZZZZZZZ.jpg')");
   } catch (Exception e) {
     e.printStackTrace();
     System.exit(1);
   }
   return new DataMountain(data);
 }
예제 #9
0
  private Graph makeEmptyMergeGraph(Table nodeTable) {
    // same nodes as original graph, but we will build different edges to show which nodes we intend
    // to merge

    Table edgeTable = new Table();
    edgeTable.addColumn(Graph.DEFAULT_SOURCE_KEY, Integer.TYPE);
    edgeTable.addColumn(Graph.DEFAULT_TARGET_KEY, Integer.TYPE);
    edgeTable.addColumn(SIMILARITY_COLUMN_NAME, Float.TYPE);

    boolean isDirected = false;
    Graph mergeGraph = new Graph(nodeTable, edgeTable, isDirected);

    return mergeGraph;
  }
예제 #10
0
  /** Graph data. */
  public GraphData() {
    super();
    nodes = new Table();
    nodes.addColumn(NHEADERS[0], NTYPES[0]);
    nodes.addColumn(NHEADERS[1], NTYPES[1]);
    nodes.addColumn(NHEADERS[2], NTYPES[2]);

    edges = new Table();
    edges.addColumn(EHEADERS[0], ETYPES[0]);
    edges.addColumn(EHEADERS[1], ETYPES[1]);
    edges.addColumn(EHEADERS[2], ETYPES[2]);

    graph = new Graph(nodes, edges, false, NHEADERS[0], EHEADERS[0], EHEADERS[1]);
  }
예제 #11
0
파일: Dichotomize.java 프로젝트: cns-iu/nwb
  public Data[] execute() {
    Graph graph = (Graph) data[0].getData();
    String attribute = (String) parameters.get("attribute");
    String comparator = (String) parameters.get("comparator");
    double cutoff = ((Double) parameters.get("cutoff")).doubleValue();

    // empty tables with the same schemas as the originals
    Table nodeTable = graph.getNodeTable().getSchema().instantiate();
    Table edgeTable = graph.getEdgeTable().getSchema().instantiate();

    // keep all nodes
    Iterator nodes = graph.getNodeTable().iterator();
    while (nodes.hasNext()) {
      nodeTable.addTuple(graph.getNodeTable().getTuple(((Integer) nodes.next()).intValue()));
    }

    // keep all edges matching the criteria
    Iterator edges = graph.getEdgeTable().iterator();
    while (edges.hasNext()) {
      Tuple tuple = graph.getEdgeTable().getTuple(((Integer) edges.next()).intValue());
      Object value = tuple.get(attribute);
      if (value != null) {
        if (passes(comparator, ((Number) value).doubleValue(), cutoff)) {
          edgeTable.addTuple(tuple);
        }
      }
    }

    Graph resultGraph =
        new Graph(
            nodeTable,
            edgeTable,
            graph.isDirected(),
            graph.getNodeKeyField(),
            graph.getEdgeSourceField(),
            graph.getEdgeTargetField());

    Data result = new BasicData(resultGraph, Graph.class.getName());
    Dictionary metadata = result.getMetadata();
    metadata.put(
        DataProperty.LABEL, "Only edges with " + attribute + " " + comparator + " " + cutoff);
    metadata.put(DataProperty.PARENT, this.data[0]);
    metadata.put(DataProperty.TYPE, DataProperty.NETWORK_TYPE);

    return new Data[] {result};
  }
예제 #12
0
 /** @see javax.swing.table.TableModel#getValueAt(int, int) */
 public Object getValueAt(int rowIndex, int columnIndex) {
   Object o = m_table.get(getRow(rowIndex), columnIndex);
   if (o != null && o.getClass().isArray()) {
     return StringLib.getArrayString(o);
   } else {
     return o;
   }
 }
예제 #13
0
  private ListMap sortNodesByAttributePrefix(
      Table nodeTable, String compareAttributeName, int numPrefixLetters) {
    ListMap nodesByAttributePrefix = new ListMap();
    // for each node in the node table...
    for (IntIterator nodeIndexIt = nodeTable.rows(); nodeIndexIt.hasNext(); ) {
      int nodeIndex = nodeIndexIt.nextInt();
      Tuple row = nodeTable.getTuple(nodeIndex);
      // get the attribute contents
      String comparisonAttributeContents = row.getString(compareAttributeName);
      if (comparisonAttributeContents == null) continue;
      // add the node index to our list map, in the bin with a key made from a prefix of the
      // attribute e.g. "do" for "donkey"
      String prefixKey = extractPrefixKey(comparisonAttributeContents, numPrefixLetters);
      nodesByAttributePrefix.put(prefixKey, new Integer(nodeIndex));
    }

    return nodesByAttributePrefix;
  }
예제 #14
0
  // this mutates nodeTable
  private Table makeMergeTable(Table nodeTable, Graph mergeGraph, StringBuffer mergeLog) {
    // get all the clusters in our merge graph (where each cluster is a group of nodes to be merged)
    List clusters = extractWeakComponentClusters(mergeGraph);
    // for each cluster...
    for (Iterator clusterIt = clusters.iterator(); clusterIt.hasNext(); ) {
      LinkedHashSet cluster = (LinkedHashSet) clusterIt.next();
      // mark that we will merge every node into a single node
      // (this step could be made smarter, but is ok for now. Will need user intervention in some
      // cases)
      Integer[] eachNodeInCluster = (Integer[]) cluster.toArray(new Integer[cluster.size()]);
      Integer firstNode = null;

      if (eachNodeInCluster.length <= 1) continue;
      for (int ii = 0; ii < eachNodeInCluster.length; ii++) {
        Integer node = eachNodeInCluster[ii];
        if (firstNode == null) {
          // (we arbitrarily choose the first node as the node to merge other nodes into)
          firstNode = node;
          String nodeOneAttribute =
              (String) nodeTable.getString(firstNode.intValue(), this.compareAttributeName);
          mergeLog.append("for \"" + nodeOneAttribute + "\"..." + "\r\n");

        } else {
          Integer nodeBeyondFirst = node;
          // (we merge nodes beyond the first into the first node)

          // (last value is off by one, because unique indices are 1-based instead of 0-based, but
          // otherwise correlate with row number.
          nodeTable.setInt(
              nodeBeyondFirst.intValue(), UNIQUE_INDEX_COLUMN_NAME, firstNode.intValue() + 1);
          String iAmNotThePrimaryNodeInCluster = "";
          nodeTable.setString(
              nodeBeyondFirst.intValue(),
              COMBINE_VALUES_COLUMN_NAME,
              iAmNotThePrimaryNodeInCluster);
          String nodeOneAttribute =
              (String) nodeTable.getString(nodeBeyondFirst.intValue(), this.compareAttributeName);
          mergeLog.append("  merging in \"" + nodeOneAttribute + "\"" + "\r\n");
        }
      }
    }

    return nodeTable;
  }
예제 #15
0
  /** @see prefuse.data.io.TableWriter#writeTable(prefuse.data.Table, java.io.OutputStream) */
  public void writeTable(Table table, OutputStream os) throws DataIOException {
    try {
      // get print stream
      PrintWriter out = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));

      // write out header row
      if (m_printHeader) {
        for (int i = 0; i < table.getColumnCount(); ++i) {
          if (i > 0) out.print(',');
          out.print(makeCSVSafe(table.getColumnName(i)));
        }
        out.println();
      }

      // write out data
      for (IntIterator rows = table.rows(); rows.hasNext(); ) {
        int row = rows.nextInt();
        for (int i = 0; i < table.getColumnCount(); ++i) {
          if (i > 0) out.print(',');
          String str = table.getString(row, table.getColumnName(i));
          out.print(makeCSVSafe(str));
        }
        out.println();
      }

      // finish up
      out.flush();
    } catch (Exception e) {
      throw new DataIOException(e);
    }
  }
예제 #16
0
  private Merger collectMerges(Table mergingTable, DatabaseTable toBeMerged, Connection connection)
      throws AlgorithmExecutionException {

    Merger merger = new Merger(toBeMerged, monitor);
    try {
      String[] primaryKeyColumns = toBeMerged.getPrimaryKeyColumns(connection);
      ColumnProjection primaryKeyColumnFilter = new NamedColumnProjection(primaryKeyColumns, true);

      ForeignKey[] foreignKeys = toBeMerged.getRelations(connection);
      for (ForeignKey foreignKey : foreignKeys) {
        // merge units are the units of work that will repoint the foreign keys referring to the
        // entities merged away to point at the primary entities
        merger.addMergeUnit(new MergeUnit(foreignKey));
      }

      TableIterator merges =
          mergingTable.iterator(
              mergingTable.rowsSortedBy(CreateMergingTable.MERGE_GROUP_IDENTIFIER_COLUMN, true));

      while (merges.hasNext()) {
        int row = merges.nextInt();
        Tuple tuple = mergingTable.getTuple(row);
        String groupIdentifier = tuple.getString(CreateMergingTable.MERGE_GROUP_IDENTIFIER_COLUMN);
        // for every key someone used for a merge group, there's an EntityGroup
        EntityGroup group =
            merger.getOrCreateEntityGroup(
                groupIdentifier, toBeMerged, primaryKeyColumnFilter, foreignKeys);
        try {
          group.addRecord(tuple);
        } catch (MergingErrorException e) {
          problems.add(e.getMessage());
        }
      }

      return merger;

    } catch (SQLException e) {
      throw new AlgorithmExecutionException("There was a problem creating the output data.", e);
    }
  }
예제 #17
0
  private Graph makeMergeGraph(Table nodeTable, StringBuffer noteLog) {
    Graph mergeGraph = makeEmptyMergeGraph(nodeTable);
    // for each group of nodes with a common attribute prefix...
    ListMap groupedNodes =
        sortNodesByAttributePrefix(nodeTable, this.compareAttributeName, this.numPrefixLetters);
    for (Iterator groupIt = groupedNodes.values().iterator(); groupIt.hasNext(); ) {
      List nodeGroup = (List) groupIt.next();
      // for each pair of nodes in the group...
      for (int i = 0; i < nodeGroup.size(); i++) {
        Integer firstNodeIndex = (Integer) nodeGroup.get(i);
        for (int j = i; j < nodeGroup.size(); j++) {
          Integer secondNodeIndex = (Integer) nodeGroup.get(j);
          // test how similar the two nodes are
          float similarity =
              compareNodesCaseInsensitiveBy(
                  this.compareAttributeName, firstNodeIndex, secondNodeIndex, nodeTable);

          // if their similarity is high enough to merge...
          if (similarity >= this.mergeOnSimilarity) {
            // link the nodes in the merge graph
            mergeGraph.addEdge(firstNodeIndex.intValue(), secondNodeIndex.intValue());
          }
          // else if their similarity is noteworthy...
          else if (similarity >= this.makeNoteOnSimilarity) {
            // record it in the log
            String nodeOneAttribute =
                (String) nodeTable.getString(firstNodeIndex.intValue(), this.compareAttributeName);
            String nodeTwoAttribute =
                (String) nodeTable.getString(secondNodeIndex.intValue(), this.compareAttributeName);
            noteLog.append("" + similarity + " similar:" + "\r\n");
            noteLog.append("  \"" + nodeOneAttribute + "\"" + "\r\n");
            noteLog.append("  \"" + nodeTwoAttribute + "\"" + "\r\n");
          }
        }
      }
    }

    return mergeGraph;
  }
예제 #18
0
 public void endElement(String namespaceURI, String localName, String qName) {
   if (qName.equals(DEFAULT)) {
     // value is in the buffer
     m_dflt = m_sbuf.toString();
   } else if (qName.equals(KEY)) {
     // time to add to the proper schema(s)
     addToSchema();
   } else if (qName.equals(DATA)) {
     // value is in the buffer
     String value = m_sbuf.toString();
     String name = (String) m_idMap.get(m_key);
     Class type = m_table.getColumnType(name);
     try {
       Object val = parse(value, type);
       m_table.set(m_row, name, val);
     } catch (DataParseException dpe) {
       error(dpe);
     }
   } else if (qName.equals(NODE) || qName.equals(EDGE)) {
     m_row = -1;
     m_table = null;
   }
 }
예제 #19
0
 private Table populateTable(Table t, Graph g) {
   for (final Iterator it = g.nodes(); it.hasNext(); ) {
     final Node n = (Node) it.next();
     t.addRow();
     for (int i = 0; i < n.getColumnCount(); i++) {
       t.set(t.getRowCount() - 1, i, n.get(i));
     }
     t.set(t.getRowCount() - 1, UNIQUE_INDEX_COLUMN_NAME, new Integer(t.getRowCount()));
   }
   return t;
 }
예제 #20
0
  @Before
  public void setUp() {
    m_vis = new Visualization();
    m_t = TableTest.getTestCaseTable();
    m_g = GraphTest.getTestCaseGraph();

    m_t0 = m_t.getTuple(0);
    m_n0 = m_g.getNode(0);

    VisualTable vt = (VisualTable) m_vis.add("t", m_t);
    VisualGraph vg = (VisualGraph) m_vis.add("g", m_g);

    m_vt0 = vt.getItem(0);
    m_vn0 = (NodeItem) vg.getNode(0);

    TupleSet ts = m_vis.getFocusGroup(Visualization.FOCUS_ITEMS);
    ts.addTuple(m_vt0);
    ts.addTuple(m_vn0);
  }
예제 #21
0
  public void testLoadFromMySQLDatabase() {
    String host = "localhost";
    String database = "friendster";
    String user = "******";
    String password = "";

    String keyField = "uid";
    String query1 =
        "SELECT profiles.* FROM profiles, graph WHERE "
            + "(graph.uid1 = 186297 AND profiles.uid = graph.uid2)";
    String query2 =
        "SELECT profiles.* FROM profiles, graph WHERE "
            + "(graph.uid1 = 21721 AND profiles.uid = graph.uid2)";

    // String query    = "SELECT gender, age, COUNT(*) FROM profiles GROUP BY gender,age";

    s_logger.info(TestConfig.memUse());

    Table t = null;
    try {
      DatabaseDataSource db = ConnectionFactory.getMySQLConnection(host, database, user, password);

      s_logger.info(TestConfig.memUse());

      t = db.getData(t, query1, keyField);
      db.loadData(t, query2, keyField);

    } catch (Exception e) {
      e.printStackTrace();
      fail("Error connecting to database");
    }

    // text-dump
    StringBuffer sbuf = new StringBuffer('\n');
    sbuf.append("--[Table: ")
        .append(t.getRowCount())
        .append(" rows, ")
        .append(t.getColumnCount())
        .append(" cols]--\n");
    for (int c = 0, idx = -1; c < t.getColumnCount(); ++c) {
      String name = t.getColumnType(c).getName();
      if ((idx = name.lastIndexOf('.')) >= 0) name = name.substring(idx + 1);
      sbuf.append(c).append("\t").append(name).append("\t").append(t.getColumnName(c)).append('\n');
    }
    sbuf.append('\n');
    sbuf.append(TestConfig.memUse()).append('\n');
    s_logger.info(sbuf.toString());

    m_table = t;
  }
예제 #22
0
  protected static List<Record> readRecordsFromTable(
      Table table,
      LogService logger,
      String labelColumn,
      String startDateColumn,
      String endDateColumn,
      String sizeByColumn,
      String startDateFormat,
      String endDateFormat,
      String categoryColumn) {
    List<Record> workingRecordSet = new ArrayList<Record>();

    for (Iterator<?> rows = table.tuples(); rows.hasNext(); ) {
      Tuple row = (Tuple) rows.next();

      try {

        Record newRecord =
            new Record(
                row,
                labelColumn,
                startDateColumn,
                endDateColumn,
                sizeByColumn,
                startDateFormat,
                endDateFormat,
                categoryColumn);

        workingRecordSet.add(newRecord);

      } catch (InvalidRecordException e) {
        logger.log(LogService.LOG_WARNING, "A record was ignored: " + e.getMessage(), e);
      }
    }

    return workingRecordSet;
  }
예제 #23
0
 /**
  * Adds a edge.
  *
  * @param node1
  * @param node2
  * @param weight
  */
 public void addEdge(long node1, long node2, double weight) {
   int row = edges.addRow();
   edges.set(row, EHEADERS[0], node1);
   edges.set(row, EHEADERS[1], node2);
   edges.set(row, EHEADERS[2], weight);
 }
예제 #24
0
 /** @see javax.swing.table.TableModel#setValueAt(java.lang.Object, int, int) */
 public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
   m_table.set(getRow(rowIndex), columnIndex, aValue);
 }
예제 #25
0
 /** @see javax.swing.table.TableModel#getColumnName(int) */
 public String getColumnName(int columnIndex) {
   return m_table.getColumnName(columnIndex);
 }
예제 #26
0
  private static JToolBar getEncodingToolbar(
      final ScatterPlot sp, final String xfield, final String yfield, final String sfield) {
    int spacing = 10;

    // create list of column names
    Table t = (Table) sp.getVisualization().getSourceData(group);
    String[] colnames = new String[t.getColumnCount()];
    for (int i = 0; i < colnames.length; ++i) colnames[i] = t.getColumnName(i);

    // create toolbar that allows visual mappings to be changed
    JToolBar toolbar = new JToolBar();
    toolbar.setLayout(new BoxLayout(toolbar, BoxLayout.X_AXIS));
    toolbar.add(Box.createHorizontalStrut(spacing));

    final JComboBox xcb = new JComboBox(colnames);
    xcb.setSelectedItem(xfield);
    xcb.addActionListener(
        new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent e) {
            Visualization vis = sp.getVisualization();
            AxisLayout xaxis = (AxisLayout) vis.getAction("x");
            xaxis.setDataField((String) xcb.getSelectedItem());
            vis.run("draw");
          }
        });
    toolbar.add(new JLabel("X: "));
    toolbar.add(xcb);
    toolbar.add(Box.createHorizontalStrut(2 * spacing));

    final JComboBox ycb = new JComboBox(colnames);
    ycb.setSelectedItem(yfield);
    ycb.addActionListener(
        new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent e) {
            Visualization vis = sp.getVisualization();
            AxisLayout yaxis = (AxisLayout) vis.getAction("y");
            yaxis.setDataField((String) ycb.getSelectedItem());
            vis.run("draw");
          }
        });
    toolbar.add(new JLabel("Y: "));
    toolbar.add(ycb);
    toolbar.add(Box.createHorizontalStrut(2 * spacing));

    final JComboBox scb = new JComboBox(colnames);
    scb.setSelectedItem(sfield);
    scb.addActionListener(
        new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent e) {
            Visualization vis = sp.getVisualization();
            DataShapeAction s = (DataShapeAction) vis.getAction("shape");
            s.setDataField((String) scb.getSelectedItem());
            vis.run("draw");
          }
        });
    toolbar.add(new JLabel("Shape: "));
    toolbar.add(scb);
    toolbar.add(Box.createHorizontalStrut(spacing));
    toolbar.add(Box.createHorizontalGlue());

    return toolbar;
  }
예제 #27
0
 /** @see javax.swing.table.TableModel#getColumnClass(int) */
 public Class getColumnClass(int columnIndex) {
   return m_table.getColumnType(columnIndex);
 }
예제 #28
0
  public Graph toGraph() {
    Table edgeTable = new Table();
    Table nodeTable = new Table();
    HashMap<String, Integer> unique = new HashMap<String, Integer>();

    edgeTable.addColumn("Node1", int.class);
    edgeTable.addColumn("Node2", int.class);
    nodeTable.addColumn("key", int.class);
    nodeTable.addColumn("name", String.class);
    nodeTable.addColumn("type", String.class);
    nodeTable.addColumn("indeterminate", int.class);

    int idx = 0;
    for (Protein prot : minProteins.values()) {
      int row = nodeTable.addRow();
      unique.put(prot.getName(), idx);
      nodeTable.setInt(row, "key", idx++);
      nodeTable.setString(row, "name", prot.getName());
      nodeTable.setString(row, "type", "protein");
      nodeTable.setInt(row, "indeterminate", 0);
    }

    for (Peptide pep : minPeptides.values()) {
      int row = nodeTable.addRow();
      unique.put(pep.getSequence(), idx);
      nodeTable.setInt(row, "key", idx++);
      nodeTable.setString(row, "name", pep.getSequence());
      nodeTable.setString(row, "type", "peptide");
      if (pep.getIndeterminateType() == PeptideIndeterminacyType.NONE) {
        nodeTable.setInt(row, "indeterminate", 0);
      } else {
        nodeTable.setInt(row, "indeterminate", 1);
      }
    }

    for (Protein prot : minProteins.values()) {
      int id1 = unique.get(prot.getName());
      for (String pep : prot.getPeptides()) {
        int id2 = unique.get(pep);
        int row = edgeTable.addRow();
        edgeTable.setInt(row, "Node1", id1);
        edgeTable.setInt(row, "Node2", id2);
      }
    }
    Graph g = new Graph(nodeTable, edgeTable, false, "key", "Node1", "Node2");
    // System.err.println(g.getEdgeCount());
    return g;
  }
예제 #29
0
 /**
  * Adds a menu item to the fisheye menu.
  *
  * @param name the menu label to use
  * @param action the ActionListener to notify when the item is clicked The prefuse VisualItem
  *     corresponding to this menu item will be returned by the ActionEvent's getSource() method.
  */
 public void addMenuItem(String name, ActionListener listener) {
   int row = m_items.addRow();
   m_items.set(row, LABEL, name);
   m_items.set(row, ACTION, listener);
 }
예제 #30
0
 /**
  * Adds a node.
  *
  * @param id
  * @param name
  * @param picture
  */
 public void addNode(long id, String name, String picture) {
   int row = nodes.addRow();
   nodes.set(row, NHEADERS[0], id);
   nodes.set(row, NHEADERS[1], name);
   nodes.set(row, NHEADERS[2], picture);
 }