Beispiel #1
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;
  }
    @Override
    public int getColor(VisualItem item) {

      // highlight border of glyphs for which search is true
      // TODO: thicker borders? more outstanding highlighting?
      // do (inefficient) manual comparison (for now)
      Iterator itemsInGroup = m_vis.getGroup(Visualization.SEARCH_ITEMS).tuples();
      while (itemsInGroup.hasNext()) {
        Tuple itemInGroup = (Tuple) itemsInGroup.next();
        if (item.getString(DocumentGridTable.NODE_NAME)
            .equals(itemInGroup.getString(DocumentGridTable.NODE_NAME))) {
          // debug
          //                    System.out.println("debug: "+this.getClass().getName()+": item in
          // group! "+item.toString());
          return ColorLib.rgb(191, 99, 130);
        }
      }

      if (item.isHover()) {
        return Color.LIGHT_GRAY.getRGB();
      }

      // default border color
      //            return ColorLib.gray(50);
      return Color.DARK_GRAY.getRGB();
    }
Beispiel #3
0
 public float getUpdateCenterY() {
   System.out.println("oink");
   TupleSet tset = getAllItems();
   for (Iterator<Tuple> it = tset.tuples(); it.hasNext(); ) {
     Tuple tuple = it.next();
     System.out.print(tuple.getString("_x"));
     System.out.print(", ");
     System.out.println(tuple.getString("_y"));
   }
   return 0.0f;
 }
Beispiel #4
0
 /** Force a refresh of all names assigned to graph nodes. */
 @SuppressWarnings("unchecked")
 void refreshNodeNames(boolean showCode, boolean abbreviate) {
   for (Iterator<Tuple> tuples = getNodes().tuples(); tuples.hasNext(); ) {
     Tuple t = tuples.next();
     ResolvedConceptReference rcr = (ResolvedConceptReference) t.get("RCR");
     if (rcr != null) {
       String code = showCode ? rcr.getConceptCode() : null;
       String desc =
           rcr.getEntityDescription() != null ? rcr.getEntityDescription().getContent() : null;
       t.set("name", getNodeName(code, desc, abbreviate, "\n"));
     }
   }
 }
Beispiel #5
0
  /**
   * Preloads images for use in a visualization. Images to load are determined by taking objects
   * from the given iterator and retrieving the value of the specified field. The items in the
   * iterator must be instances of the {@link prefuse.data.Tuple} class.
   *
   * <p>Images are loaded in the order specified by the iterator until the the iterator is empty or
   * the maximum image cache size is met. Thus higher priority images should appear sooner in the
   * iteration.
   *
   * @param iter an Iterator of {@link prefuse.data.Tuple} instances
   * @param field the data field that contains the image location
   */
  public void preloadImages(Iterator iter, String field) {
    boolean synch = m_asynch;
    m_asynch = false;

    String loc = null;
    while (iter.hasNext() && imageCache.size() <= m_imageCacheSize) {
      // get the string describing the image location
      Tuple t = (Tuple) iter.next();
      loc = t.getString(field);
      if (loc != null) {
        getImage(loc);
      }
    }
    m_asynch = synch;
  }
Beispiel #6
0
  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};
  }
Beispiel #7
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;
  }
 public boolean getBoolean(Tuple t) {
   if (t instanceof Node) {
     System.err.println("===" + ((Node) t).getInt(NODECOUNT));
     if (((Node) t).getDepth() == 0) return true;
     else return t.canGetInt(NODECOUNT) && ((Node) t).getInt(NODECOUNT) > cutoff_frequency;
   }
   if (((Edge) t).getSourceNode().getInt(NODECOUNT) <= cutoff_frequency) return false;
   if (((Edge) t).getTargetNode().getInt(NODECOUNT) <= cutoff_frequency) return false;
   return true;
 }
Beispiel #9
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);
    }
  }