public void testShortestPath() {

    // graph.prettyPrint();
    IndexedWord word1 = graph.getNodeByIndex(10);
    IndexedWord word2 = graph.getNodeByIndex(14);
    // System.out.println("word1: " + word1);
    // System.out.println("word1: " + word1.hashCode());
    // System.out.println("word2: " + word2);
    // System.out.println("word2: " + word2.hashCode());
    // System.out.println("word eq: " + word1.equals(word2));
    // System.out.println("word eq: " + (word1.hashCode() == word2.hashCode()));
    // System.out.println("word eq: " + (word1.toString().equals(word2.toString())));

    List<SemanticGraphEdge> edges = graph.getShortestUndirectedPathEdges(word1, word2);
    // System.out.println("path: " + edges);
    assertNotNull(edges);

    List<IndexedWord> nodes = graph.getShortestUndirectedPathNodes(word1, word2);
    // System.out.println("path: " + nodes);
    assertNotNull(nodes);
    assertEquals(word1, nodes.get(0));
    assertEquals(word2, nodes.get(nodes.size() - 1));

    edges = graph.getShortestUndirectedPathEdges(word1, word1);
    // System.out.println("path: " + edges);
    assertNotNull(edges);
    assertEquals(0, edges.size());

    nodes = graph.getShortestUndirectedPathNodes(word1, word1);
    // System.out.println("path: " + nodes);
    assertNotNull(nodes);
    assertEquals(1, nodes.size());
    assertEquals(word1, nodes.get(0));
  }
 public void testIsAncestor() {
   // System.err.println(graph.toString(CoreLabel.VALUE_TAG_INDEX_FORMAT));
   assertEquals(1, graph.isAncestor(graph.getNodeByIndex(42), graph.getNodeByIndex(45)));
   assertEquals(2, graph.isAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(37)));
   assertEquals(-1, graph.isAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(38)));
   assertEquals(-1, graph.isAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(10)));
   assertEquals(-1, graph.isAncestor(graph.getNodeByIndex(45), graph.getNodeByIndex(42)));
 }
  public void testHasChildren() {
    SemanticGraph gr = SemanticGraph.valueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");

    List<IndexedWord> vertices = gr.vertexListSorted();
    for (IndexedWord word : vertices) {
      if (word.word().equals("ate") || word.word().equals("muffins")) {
        assertTrue(gr.hasChildren(word));
      } else {
        assertFalse(gr.hasChildren(word));
      }
    }
  }
  /**
   * Tests that a particular topological sort is correct by verifying for each node that it appears
   * in the sort and all of its children occur later in the sort
   */
  private static void verifyTopologicalSort(SemanticGraph graph) {
    List<IndexedWord> sorted = graph.topologicalSort();

    Map<IndexedWord, Integer> indices = Generics.newHashMap();
    for (int index = 0; index < sorted.size(); ++index) {
      indices.put(sorted.get(index), index);
    }

    for (IndexedWord parent : graph.vertexSet()) {
      assertTrue(indices.containsKey(parent));
      int parentIndex = indices.get(parent);
      for (IndexedWord child : graph.getChildren(parent)) {
        assertTrue(indices.containsKey(child));
        int childIndex = indices.get(child);
        assertTrue(parentIndex < childIndex);
      }
    }
  }
 public void testCommonAncestor() {
   IndexedWord word1 = graph.getNodeByIndex(43);
   IndexedWord word2 = graph.getNodeByIndex(44);
   IndexedWord common = graph.getCommonAncestor(word1, word2);
   System.out.println("word1: " + word1);
   System.out.println("word2: " + word2);
   System.out.println("common: " + common);
   System.out.println(
       "common ancestor between  "
           + word1.value()
           + "-"
           + word1.index()
           + " and "
           + word2.value()
           + "-"
           + word2.index()
           + " is "
           + common.value()
           + "-"
           + common.index());
   assertEquals(45, common.index());
 }
Exemple #6
0
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    canvas.scale(mScale, mScale, mFocusX, mFocusY);
    canvas.translate(mStartX, mStartY);
    canvas.rotate(mAngle);

    Rect bounds = new Rect();

    float dx = mGraph.getLayoutMinX();
    float sx = getWidth() / (mGraph.getLayoutMaxX() - mGraph.getLayoutMinX());
    float dy = mGraph.getLayoutMinY();
    float sy = getHeight() / (mGraph.getLayoutMaxY() - mGraph.getLayoutMinY());
    for (SemanticGraph.Node node : mGraph.getNodes()) {
      mPaint.getTextBounds(node.getLemma().toCharArray(), 0, node.getLemma().length(), bounds);

      float left = (node.getLayoutX() - dx) * sx - TEXT_PAD;
      float base = (node.getLayoutY() - dy) * sy;
      float top = base - bounds.height() - TEXT_PAD;
      float right = left + bounds.right + TEXT_PAD;
      float bottom = base + bounds.bottom + TEXT_PAD;
      float sqrt2 = (float) Math.sqrt(2);

      canvas.drawText(node.getLemma(), left + TEXT_PAD, base, mPaint);

      float pi = (float) Math.PI;
      for (int i = 0; i < node.getSenseCount(); i++) {
        float phi = i * 2 * pi / node.getSenseCount();
        float cx = ((left + right) + (right - left) * sqrt2 * ((float) Math.sin(phi))) / 2;
        float cy = ((top + bottom) + (bottom - top) * sqrt2 * ((float) Math.cos(phi))) / 2;

        canvas.drawCircle(cx, cy, SENSE_POINT_RADIUS, mPaint);
      }
    }
  }
Exemple #7
0
 public void refresh() {
   mGraph.layout();
   invalidate();
 }
  public void testGetCommonAncestor() {
    IndexedWord common =
        graph.getCommonAncestor(graph.getNodeByIndex(43), graph.getNodeByIndex(44));
    assertEquals(45, common.index());

    common = graph.getCommonAncestor(graph.getNodeByIndex(41), graph.getNodeByIndex(39));
    assertEquals(41, common.index());

    common = graph.getCommonAncestor(graph.getNodeByIndex(39), graph.getNodeByIndex(41));
    assertEquals(41, common.index());

    common = graph.getCommonAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(42));
    assertEquals(41, common.index());

    // too far for this method
    common = graph.getCommonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(42));
    assertEquals(null, common);

    common = graph.getCommonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(10));
    assertEquals(10, common.index());

    common = graph.getCommonAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(40));
    assertEquals(40, common.index());

    // a couple tests at the top of the graph
    common = graph.getCommonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(1));
    assertEquals(10, common.index());

    common = graph.getCommonAncestor(graph.getNodeByIndex(1), graph.getNodeByIndex(10));
    assertEquals(10, common.index());
  }
 public void testGetSiblings() {
   verifySet(graph.getSiblings(graph.getNodeByIndex(43)), 42, 44, 48);
   verifySet(graph.getSiblings(graph.getNodeByIndex(10))); // empty set
   verifySet(graph.getSiblings(graph.getNodeByIndex(42)), 43, 44, 48);
 }
 public void testGetPathToRoot() {
   verifyPath(graph.getPathToRoot(graph.getNodeByIndex(1)), 4, 10);
   verifyPath(graph.getPathToRoot(graph.getNodeByIndex(10))); // empty path
   verifyPath(graph.getPathToRoot(graph.getNodeByIndex(34)), 35, 28, 10);
 }
  public void testTopologicalSort() {
    SemanticGraph gr = SemanticGraph.valueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
    verifyTopologicalSort(gr);

    List<IndexedWord> vertices = gr.vertexListSorted();
    gr.addEdge(
        vertices.get(1),
        vertices.get(2),
        UniversalEnglishGrammaticalRelations.DIRECT_OBJECT,
        1.0,
        false);
    verifyTopologicalSort(gr);

    gr = SemanticGraph.valueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
    vertices = gr.vertexListSorted();
    gr.addEdge(
        vertices.get(2),
        vertices.get(1),
        UniversalEnglishGrammaticalRelations.DIRECT_OBJECT,
        1.0,
        false);
    verifyTopologicalSort(gr);

    gr = SemanticGraph.valueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
    vertices = gr.vertexListSorted();
    gr.addEdge(
        vertices.get(1),
        vertices.get(3),
        UniversalEnglishGrammaticalRelations.DIRECT_OBJECT,
        1.0,
        false);
    verifyTopologicalSort(gr);

    // now create a graph with a directed loop, which we should not
    // be able to topologically sort
    gr = SemanticGraph.valueOf("[ate subj>Bill dobj>[muffins compound>blueberry]]");
    vertices = gr.vertexListSorted();
    gr.addEdge(
        vertices.get(3),
        vertices.get(0),
        UniversalEnglishGrammaticalRelations.DIRECT_OBJECT,
        1.0,
        false);
    try {
      verifyTopologicalSort(gr);
      throw new RuntimeException("Expected to fail");
    } catch (IllegalStateException e) {
      // yay, correctly caught error
    }
  }
  public void testCommonAncestor() {
    assertEquals(1, graph.commonAncestor(graph.getNodeByIndex(43), graph.getNodeByIndex(44)));

    assertEquals(1, graph.commonAncestor(graph.getNodeByIndex(41), graph.getNodeByIndex(39)));

    assertEquals(1, graph.commonAncestor(graph.getNodeByIndex(39), graph.getNodeByIndex(41)));

    assertEquals(2, graph.commonAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(42)));

    assertEquals(2, graph.commonAncestor(graph.getNodeByIndex(42), graph.getNodeByIndex(40)));

    // too far for this method
    assertEquals(-1, graph.commonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(42)));
    // assertEquals(null, common);

    assertEquals(0, graph.commonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(10)));

    assertEquals(0, graph.commonAncestor(graph.getNodeByIndex(40), graph.getNodeByIndex(40)));
    // assertEquals(40, common.index());

    // a couple tests at the top of the graph
    assertEquals(2, graph.commonAncestor(graph.getNodeByIndex(10), graph.getNodeByIndex(1)));

    assertEquals(2, graph.commonAncestor(graph.getNodeByIndex(1), graph.getNodeByIndex(10)));
  }