コード例 #1
0
  /** @see prefuse.action.Action#run(double) */
  public void run(double frac) {

    Graph g = (Graph) m_vis.getGroup(m_group);
    initSchema(g.getNodes());

    m_origin = getLayoutAnchor();
    NodeItem n = getLayoutRoot();
    Params np = (Params) n.get(PARAMS);

    // calc relative widths and maximum tree depth
    // performs one pass over the tree
    m_maxDepth = 0;
    calcAngularWidth(n, 0);

    if (m_autoScale) setScale(getLayoutBounds());
    if (!m_setTheta) calcAngularBounds(n);

    // perform the layout
    if (m_maxDepth > 0) layout(n, m_radiusInc, m_theta1, m_theta2);

    // update properties of the root node
    setX(n, null, m_origin.getX());
    setY(n, null, m_origin.getY());
    np.angle = m_theta2 - m_theta1;
  }
コード例 #2
0
  /**
   * Compute the layout.
   *
   * @param n the root of the current subtree under consideration
   * @param r the radius, current distance from the center
   * @param theta1 the start (in radians) of this subtree's angular region
   * @param theta2 the end (in radians) of this subtree's angular region
   */
  protected void layout(NodeItem n, double r, double theta1, double theta2) {
    double dtheta = (theta2 - theta1);
    double dtheta2 = dtheta / 2.0;
    double width = ((Params) n.get(PARAMS)).width;
    double cfrac, nfrac = 0.0;

    Iterator childIter = sortedChildren(n);
    while (childIter != null && childIter.hasNext()) {
      NodeItem c = (NodeItem) childIter.next();
      Params cp = (Params) c.get(PARAMS);
      cfrac = cp.width / width;
      if (c.isExpanded() && c.getChildCount() > 0) {
        layout(c, r + m_radiusInc, theta1 + nfrac * dtheta, theta1 + (nfrac + cfrac) * dtheta);
      }
      setPolarLocation(c, n, r, theta1 + nfrac * dtheta + cfrac * dtheta2);

      cp.angle = cfrac * dtheta;
      nfrac += cfrac;
    }
  }
コード例 #3
0
  /**
   * Calculates the angular bounds of the layout, attempting to preserve the angular orientation of
   * the display across transitions.
   */
  private void calcAngularBounds(NodeItem r) {
    if (m_prevRoot == null || !m_prevRoot.isValid() || r == m_prevRoot) {
      m_prevRoot = r;
      return;
    }

    // try to find previous parent of root
    NodeItem p = m_prevRoot;
    while (true) {
      NodeItem pp = (NodeItem) p.getParent();
      if (pp == r) {
        break;
      } else if (pp == null) {
        m_prevRoot = r;
        return;
      }
      p = pp;
    }

    // compute offset due to children's angular width
    double dt = 0;
    Iterator iter = sortedChildren(r);
    while (iter.hasNext()) {
      Node n = (Node) iter.next();
      if (n == p) break;
      dt += ((Params) n.get(PARAMS)).width;
    }
    double rw = ((Params) r.get(PARAMS)).width;
    double pw = ((Params) p.get(PARAMS)).width;
    dt = -MathLib.TWO_PI * (dt + pw / 2) / rw;

    // set angular bounds
    m_theta1 = dt + Math.atan2(p.getY() - r.getY(), p.getX() - r.getX());
    m_theta2 = m_theta1 + MathLib.TWO_PI;
    m_prevRoot = r;
  }
コード例 #4
0
  /**
   * Computes relative measures of the angular widths of each expanded subtree. Node diameters are
   * taken into account to improve space allocation for variable-sized nodes.
   *
   * <p>This method also updates the base angle value for nodes to ensure proper ordering of nodes.
   */
  private double calcAngularWidth(NodeItem n, int d) {
    if (d > m_maxDepth) m_maxDepth = d;
    double aw = 0;

    Rectangle2D bounds = n.getBounds();
    double w = bounds.getWidth(), h = bounds.getHeight();
    double diameter = d == 0 ? 0 : Math.sqrt(w * w + h * h) / d;

    if (n.isExpanded() && n.getChildCount() > 0) {
      Iterator childIter = n.children();
      while (childIter.hasNext()) {
        NodeItem c = (NodeItem) childIter.next();
        aw += calcAngularWidth(c, d + 1);
      }
      aw = Math.max(diameter, aw);
    } else {
      aw = diameter;
    }
    ((Params) n.get(PARAMS)).width = aw;
    return aw;
  }