java实现的R树

package rtree;

import java.util.*;
import java.io.*;

/**
 * Implements basic functions of Node interface. Also implements splitting functions.
 * 

 * Created: Tue May 18 15:57:56 1999
 * 

 * @author Hadjieleftheriou Marios
 * @version 1.1
 */
public abstract class AbstractNode implements Node {
    /** Level of this node. Leaves always have a level equal to 0. */
    protected int level;

    /** Parent of all nodes. */
    protected transient RTree tree;

    /** The pageNumber where the parent of this node is stored. */
    protected int parent;

    /** The pageNumber where this node is stored. */
    protected int pageNumber;

    /**
     * All node data are stored into this array. It must have a size of nodeCapacity + 1 to hold
     * all data plus an overflow HyperCube when the node must be split.
     */
    protected HyperCube[] data;

    /**
     * Holds the pageNumbers containing the children of this node. Always has same size with the data array.
     * If this is a Leaf node than all branches should point to the real data objects.
     */
    protected int[] branches;

    /** How much space is used up into this node. If equal to nodeCapacity then node is full. */
    protected int usedSpace;

//
// Initialization.
//

    protected AbstractNode（RTree tree int parent int pageNumber int level） {
	this.parent = parent;
	this.tree = tree;
	this.pageNumber = pageNumber;
	this.level = level;
	data = new HyperCube[tree.getNodeCapacity（）+1];
	branches = new int[tree.getNodeCapacity（）+1];
	usedSpace = 0;
    }

//
// Node interface.
//

    /**
     * Returns the node level. Always zero for leaf nodes.
     *
     * @return Level of node.
     */
    public int getLevel（） {
	return level;
    }

    /**
     *  Returns true if this node is the root node.
     */
    public boolean isRoot（） {
	return （parent == RTree.NIL）;
    }

    /**
     *  Returns true if this node is an Index. Root node is an Index too unless it is a Leaf.
     */
    public boolean isIndex（） {
	return （level != 0）;
    }

    /**
     * Returns true if this node is a Leaf. Root may be a Leaf too.
     */
    public boolean isLeaf（） {
	return （level == 0）;
    }

    /**
     * Returns the mbb of all HyperCubes present in this node.
     *
     * @return A new HyperCube object representing the mbb of this node.
     */
    public HyperCube getNodeMbb（） {
	if （usedSpace > 0） {
	    HyperCube[] h = new HyperCube[usedSpace];
	    System.arraycopy（data 0 h 0 usedSpace）;
	    return HyperCube.getUnionMbb（h）;
	} else {
	    return new HyperCube（new Point（new float[] {0 0}） new Point（new float[] {0 0}））;
	}
    }

    /**
     * Returns a unique id for this node. The page number is unique for every node but
     * it doen‘t signify anything about where in the path from the root this node lies it is random.
     * This function returns a point separated list of page numbers from the root up to the
     * current node. It is expensive though