weka.gui.treevisualizer.PlaceNode1 Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of weka-dev Show documentation

The Waikato Environment for Knowledge Analysis (WEKA), a machine learning workbench. This version represents the developer version, the "bleeding edge" of development, you could say. New functionality gets added to this version.

There is a newer version: 3.9.6

Show newest version

/*
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see .
 */

/*
 *    PlaceNode1.java
 *    Copyright (C) 1999-2012 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.gui.treevisualizer;

/**
 * This class will place the Nodes of a tree.
 * 
 * 
 * It will place these nodes so that they symetrically fill each row. This is
 * simple to calculate but is not visually nice for most trees.
 * 
 * 
 * @author Malcolm F Ware ([email protected])
 * @version $Revision: 10222 $
 */
public class PlaceNode1 implements NodePlace {
  /** An array containing the spacing value for each level */
  private double[] m_levels; // contains num of nodes one each level

  /** The number of levels in the tree */
  private int m_noLevels;// contains num of levels

  /**
   * An array containing the current node place for each level to place each
   * node accordingly.
   */
  private int[] m_levelNode; // contains num of node upto on particular level

  /** The distance between each level. */
  private double m_yRatio; // for quicker running y_ratio is a constant after

  // being calculated
  /**
   * Call this function to have each node in the tree starting at 'r' placed in
   * a visual (not logical, they already are) tree position.
   * 
   * @param r The top of the tree.
   */
  @Override
  public void place(Node r) {
    /*
     * this is the first and most basic algorithm to write I will use this as a
     * reference to test the classes
     * 
     * this works by counting up the nodes on each level and spacing the level
     * evenly so that it is all used
     */

    /*
     * this loop will work by starting at the first node and systematically
     * going through all their children from left to right.but first it will do
     * a quick pass to find out the number of levels there are
     */

    // + 1 so that no nodes are on edge of screen
    m_noLevels = Node.getHeight(r, 0) + 1;

    m_yRatio = 1 / (double) m_noLevels;

    m_levels = new double[m_noLevels];
    m_levelNode = new int[m_noLevels];
    for (int noa = 0; noa < m_noLevels; noa++) {
      m_levels[noa] = 1;
      m_levelNode[noa] = 0;
    }

    setNumOfNodes(r, 0);

    for (int noa = 0; noa < m_noLevels; noa++) {
      m_levels[noa] = 1 / m_levels[noa];
    }

    placer(r, 0);
  }

  /**
   * This function finds the number of nodes on each level recursively.
   * 
   * @param r The current Node upto.
   * @param l The current level upto.
   */
  private void setNumOfNodes(Node r, int l) {
    Edge e;
    l++;

    m_levels[l]++;
    for (int noa = 0; (e = r.getChild(noa)) != null && r.getCVisible(); noa++) {
      setNumOfNodes(e.getTarget(), l);
    }
  }

  /**
   * This function goes through and sets the position of each node
   * 
   * @param r The current node upto.
   * @param l the current level upto.
   */
  private void placer(Node r, int l) {
    Edge e;
    l++;
    m_levelNode[l]++;
    r.setCenter(m_levelNode[l] * m_levels[l]);
    r.setTop(l * m_yRatio);
    for (int noa = 0; (e = r.getChild(noa)) != null && r.getCVisible(); noa++) {
      placer(e.getTarget(), l);
    }
  }
}