Rtree scala error, Scala

Language: Layout:

import java.util.HashMap
import java.util.HashSet
import java.util.LinkedList
import java.util.List
import java.util.ListIterator
import java.util.Map
import java.util.Queue
import java.util.Set
import RTree._
import scala.beans.{BeanProperty, BooleanBeanProperty}

//remove if not needed
import scala.collection.JavaConversions._

object RTree {
  object SeedPicker extends Enumeration {
    
    
      @BeanProperty
  var maxEntries: Int = _

@BeanProperty
  var minEntries: Int = _

@BeanProperty
  var numDims: Int = _

private var pointDims: Array[Float] = _

private var seedPicker: SeedPicker = _

private var root: Node = _

var size: Int = _

val LINEAR: SeedPicker = new SeedPicker()

val QUADRATIC: SeedPicker = new SeedPicker()

class SeedPicker extends Val
   
    implicit def convertValue(v: Value): SeedPicker =
      v.asInstanceOf[SeedPicker]

/**
  * Creates a new RTree.
  *
  * @param maxEntries maximum number of entries per node
  * @param minEntries minimum number of entries per node (except for the root node)
  * @param numDims    the number of dimensions of the RTree.
  */

class RTree[T]
(private val maxEntries: Int,
 private val minEntries: Int,
 private val numDims: Int,
 private val seedPicker: SeedPicker) {

private val pointDims: Array[Float] = new Array[Float](numDims)

private var root: Node = buildRoot(true)

@volatile private var size: Int = _

assert((minEntries <= (maxEntries / 2)))

}

private def buildRoot(asLeaf: Boolean): Node = {
    val initCoords: Array[Float] = Array.ofDim[Float](numDims)
    val initDimensions: Array[Float] = Array.ofDim[Float](numDims)
    for (i <- 0 until this.numDims) {
      initCoords(i) = Math.sqrt(java.lang.Float.MAX_VALUE).toFloat
      initDimensions(i) = -2.0f * Math.sqrt(java.lang.Float.MAX_VALUE).toFloat
    }
    new Node(initCoords, initDimensions, asLeaf)
  }
  
   /**
     * Searches the RTree for objects overlapping with the given rectangle.
     *
     * @param coords     the corner of the rectangle that is the lower bound of every
     *                   dimension (eg. the top-left corner)
     * @param dimensions the dimensions of the rectangle.
     * @return a list of objects whose rectangles overlap with the given
     * rectangle.
     */
  
   def search(coords: Array[Float], dimensions: Array[Float]): List[T] = {
    assert((coords.length == numDims))
    assert((dimensions.length == numDims))
    val results: LinkedList[T] = new LinkedList[T]()
    search(coords, dimensions, root, results)
    results
  }
  
    private def search(coords: Array[Float],
                     dimensions: Array[Float],
                     n: Node,
                     results: LinkedList[T]): Unit = {
      
    if (n.leaf) {
      for (e <- n.children
           if isOverlap(coords, dimensions, e.coords, e.dimensions)) {
        results.add(e.asInstanceOf[Entry].entry)
      }
    } else {
      for (c <- n.children
           if isOverlap(coords, dimensions, c.coords, c.dimensions)) {
        search(coords, dimensions, c, results)
      }
    }
  
}
     /**
     * Deletes the entry associated with the given rectangle from the RTree
     *
     * @param coords     the corner of the rectangle that is the lower bound in every
     *                   dimension
     * @param dimensions the dimensions of the rectangle
     * @param entry      the entry to delete
     * @return true iff the entry was deleted from the RTree.
     */
    def delete(coords: Array[Float],
             dimensions: Array[Float],
             entry: T): Boolean = {
    assert((coords.length == numDims))
    assert((dimensions.length == numDims))
    val l: Node = findLeaf(root, coords, dimensions, entry)
    if (l == null) {
      println("WTF?")
      findLeaf(root, coords, dimensions, entry)
    }
//assert (l.leaf) : "Entry is not found at leaf?!?";
    val li: ListIterator[Node] = l.children.listIterator()
    var removed: T = null
    while (li.hasNext) {
      val e: Entry = li.next().asInstanceOf[Entry]
      if (e.entry == entry) {
        removed = e.entry
        li.remove()
//break
      }
    }
    if (removed != null) {
      condenseTree(l) { size -= 1; size + 1 }
    }
    if (size == 0) {
      root = buildRoot(true)
    }
    (removed != null)
  }
// assert (l != null) : "Could not find leaf for entry to delete";
// assert (l != null) : "Could not find leaf for entry to delete";
      def delete(coords: Array[Float], entry: T): Boolean =    delete(coords, pointDims, entry)
    
    
  def findLeaf(n: Node,coords: Array[Float],dimensions: Array[Float],entry: T): Node ={
    if (n.leaf) {
      n.children
        .find(_.asInstanceOf[Entry].entry == entry)
        .map(_ => n)
        .getOrElse(null)
    } else {
      for (c <- n.children
           if isOverlap(c.coords, c.dimensions, coords, dimensions)) {
        val result: Node = findLeaf(c, coords, dimensions, entry)
        if (result != null) {
          result
        }
      }
      null
    }
  }
      
    private def condenseTree(n: Node): Unit = {
    val q: Set[Node] = new HashSet[Node]()
    while (n != root) {
      if (n.leaf && (n.children.size < minEntries)) {
        q.addAll(n.children)
        n.parent.children.remove(n)
      } else if (!n.leaf && (n.children.size < minEntries)) {
// probably a more efficient way to do this...
        val toVisit: LinkedList[Node] = new LinkedList[Node](n.children)
        while (!toVisit.isEmpty) {
          val c: Node = toVisit.pop()
          if (c.leaf) {
            q.addAll(c.children)
          } else {
            toVisit.addAll(c.children)
          }
        }
        n.parent.children.remove(n)
      } else {
        tighten(n)
      }
      n = n.parent
    }
    if (root.children.size == 0) {
      root = buildRoot(true)
    } else if ((root.children.size == 1) && (!root.leaf)) {
      root = root.children.get(0)
      root.parent = null
    } else {
      tighten(root)
    }
    for (ne <- q) {
      val e: Entry = ne.asInstanceOf[Entry]
      insert(e.coords, e.dimensions, e.entry)
    }
    size -= q.size
  }   
      
       
      //Empties the RTree
     
      
       def clear(): Unit = {
    root = buildRoot(true)
  }
        /**
     * Inserts the given entry into the RTree, associated with the given
     * rectangle.
     *
     * @param coords     the corner of the rectangle that is the lower bound in every
     *                   dimension
     * @param dimensions the dimensions of the rectangle
     * @param entry      the entry to insert
     */
       
     def insert(coords: Array[Float], dimensions: Array[Float], entry: T): Unit = {
    assert((coords.length == numDims))
    assert((dimensions.length == numDims))
    val e: Entry = new Entry(coords, dimensions, entry)
    val l: Node = chooseLeaf(root, e)
    l.children.add(e) { size += 1; size - 1 }
    e.parent = l
    if (l.children.size > maxEntries) {
      val splits: Array[Node] = splitNode(l)
      adjustTree(splits(0), splits(1))
    } else {
      adjustTree(l, null)
    }
  }

/**
     * Convenience method for inserting a point
     *
     * @param coords
     * @param entry
     */
      
        def insert(coords: Array[Float], entry: T): Unit = {
    insert(coords, pointDims, entry)
  }
        
        def visit(nv: NodeVisitor[T]): Unit = {
    val coordBuf: Array[Float] = Array.ofDim[Float](numDims)
    val dimBuf: Array[Float] = Array.ofDim[Float](numDims)
    val toVisit: Queue[Node] = new LinkedList[Node]()
    val nodeDepths: Map[Node, Integer] = new HashMap[Node, Integer]()
    nodeDepths.put(root, 0)
    toVisit.add(root)
    while (!toVisit.isEmpty) {
      val currentNode: Node = toVisit.remove()
      if (currentNode.parent != null) {
        nodeDepths.put(currentNode, nodeDepths.get(currentNode.parent) + 1)
      }
      System.arraycopy(currentNode.coords, 0, coordBuf, 0, numDims)
      System.arraycopy(currentNode.dimensions, 0, dimBuf, 0, numDims)
      if (currentNode.isInstanceOf[RTree.Entry]) {
        nv.visit(nodeDepths.get(currentNode),
                 coordBuf,
                 dimBuf,
                 currentNode.asInstanceOf[Entry].entry)
      } else {
        nv.visit(nodeDepths.get(currentNode), coordBuf, dimBuf, null)
      }
      toVisit.addAll(currentNode.children)
    }
  }

private def adjustTree(n: Node, nn: Node): Unit = {
    if (n == root) {
      if (nn != null) {
// build new root and add children.
        root = buildRoot(false)
        root.children.add(n)
        n.parent = root
        root.children.add(nn)
        nn.parent = root
      }
      tighten(root)
      return
    }
    tighten(n)
    if (nn != null) {
      tighten(nn)
      if (n.parent.children.size > maxEntries) {
        val splits: Array[Node] = splitNode(n.parent)
        adjustTree(splits(0), splits(1))
      }
    }
    if (n.parent != null) {
      adjustTree(n.parent, null)
    }
  }
         trait NodeVisitor[V] {
     
    def visit(depth: Int,
              coords: Array[Float],
              dimensions: Array[Float],
              value: V): Unit

}
 
 // TODO: this class probably calls "tighten" a little too often.
// For instance the call at the end of the "while (!cc.isEmpty())" loop
// could be modified and inlined because it's only adjusting for the addition
 
          private def splitNode(n: Node): Array[Node] = {
// of a single node.  Left as-is for now for readability.
    val nn: Array[Node] = Array(n, new Node(n.coords, n.dimensions, n.leaf))
    nn(1).parent = n.parent
    if (nn(1).parent != null) {
      nn(1).parent.children.add(nn(1))
    }
    val cc: LinkedList[Node] = new LinkedList[Node](n.children)
    n.children.clear()
    val ss: Array[Node] =
      if (seedPicker == SeedPicker.LINEAR) lPickSeeds(cc) else qPickSeeds(cc)
    nn(0).children.add(ss(0))
    nn(1).children.add(ss(1))
    tighten(nn)
    while (!cc.isEmpty) {
      if ((nn(0).children.size >= minEntries) && (nn(1).children.size + cc.size == minEntries)) {
        nn(1).children.addAll(cc)
        cc.clear()
// Not sure this is required.
        tighten(nn)
        nn
      } else if ((nn(1).children.size >= minEntries) && (nn(0).children.size + cc.size == minEntries)) {
        nn(0).children.addAll(cc)
        cc.clear()
// Not sure this is required.
        tighten(nn)
        nn
      }
      val c: Node =
        if (seedPicker == SeedPicker.LINEAR) lPickNext(cc)
        else qPickNext(cc, nn)
      var preferred: Node = null
      val e0: Float = getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
      val e1: Float = getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
      if (e0 < e1) {
        preferred = nn(0)
      } else if (e0 > e1) {
        preferred = nn(1)
      } else {
        val a0: Float = getArea(nn(0).dimensions)
        val a1: Float = getArea(nn(1).dimensions)
        preferred =
          if (a0 < a1) nn(0)
          else if (e0 > a1) nn(1)
          else if (nn(0).children.size < nn(1).children.size) nn(0)
          else if (nn(0).children.size > nn(1).children.size) nn(1)
          else nn(Math.round(Math.random()).toInt)
      }
      preferred.children.add(c)
      tighten(preferred)
    }
    nn
  }
// Implementation of Quadratic PickSeeds
          
          
          
          
          def qPickSeeds[T] ( nn: LinkedList[Node],T:Array[Node],f: RTree[T] => Unit): Unit ={
        // @SuppressWarnings("unchecked")

val bestPair: Array[Node] = Array(2)
            for ( n1<- nn){
              for(n2<-nn){
                if (n1==n2){
                 var n1a: Float = getArea(n1.dimensions)
                 var n2a: Float = getArea(n1.dimensions)
                 var ja: Float = 1.0f
                
                 for(i <- 0 until numDims) {
                   var jc0: Float = Math.min(n1.coords(i), n2.coords(i))
                   var jc1: Float =Math.max(n1.coords(i) + n1.dimensions(i), n2.coords(i) + n2.dimensions(i))
                  // var ja*=(jc1-jc0)
                 }
                   
                   
                   
                } 
              }
              
              
            }
          }
          
          
         /**
     * Implementation of QuadraticPickNext
     *
     * @param cc the children to be divided between the new nodes, one item will be removed from this list.
     * @param nn the candidate nodes for the children to be added to.
     */
          
            private def qPickNext(cc: LinkedList[Node], nn: Array[Node]): Node = {
    var maxDiff: Float = -1.0f * java.lang.Float.MAX_VALUE
    var nextC: Node = null
    for (c <- cc) {
      val n0Exp: Float =
        getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
      val n1Exp: Float =
        getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
      val diff: Float = Math.abs(n1Exp - n0Exp)
      if (diff > maxDiff) {
        maxDiff = diff
        nextC = c
      }
    }
//  assert (nextC != null) : "No node selected from qPickNext";
    cc.remove(nextC)
    nextC
  }
          
    // Implementation of LinearPickSeeds
            
 def lPickSeeds ( nn: LinkedList[Node],T:Array[Node],f: RTree[T] => Unit): Unit ={
             val foundBestPair: Boolean = false
            val bestSep: Float = 0.0f
              
    for (i <- 0 until numDims) {
      var dimLb: Float = java.lang.Float.MAX_VALUE
      var dimMinUb: Float = java.lang.Float.MAX_VALUE
      var dimUb: Float = -1.0f * java.lang.Float.MAX_VALUE
      var dimMaxLb: Float = -1.0f * java.lang.Float.MAX_VALUE
      var nMaxLb: Node = null
      var nMinUb: Node = null
      for (n <- nn) {
        if (n.coords(i) < dimLb) {
          dimLb = n.coords(i)
        }
        if (n.dimensions(i) + n.coords(i) > dimUb) {
          dimUb = n.dimensions(i) + n.coords(i)
        }
        if (n.coords(i) > dimMaxLb) {
          dimMaxLb = n.coords(i)
          nMaxLb = n
        }
        if (n.dimensions(i) + n.coords(i) < dimMinUb) {
          dimMinUb = n.dimensions(i) + n.coords(i)
          nMinUb = n
        }
      }
    }
              val sep: Float =
      if ((nMaxLb == nMinUb)) -1.0f
      else Math.abs((dimMinUb - dimMaxLb) / (dimUb - dimLb))
    if (sep >= bestSep) {
      bestPair(0) = nMaxLb
      bestPair(1) = nMinUb
      bestSep = sep
      foundBestPair = true
    }
             
             if (!foundBestPair) {
      bestPair = Array(nn.get(0), nn.get(1))
    }
    nn.remove(bestPair(0))
    nn.remove(bestPair(1))
    bestPair
             
             
             
             
 }      
    /**
     * Implementation of LinearPickNext
     *
     * @param cc the children to be divided between the new nodes, one item will be removed from this list.
     */       
           private def lPickNext(cc: LinkedList[Node]): Node = cc.pop()
          
           private def tighten(nodes: Node*): Unit = {
// assert (nodes.length >= 1) : "Pass some nodes to tighten!";
    for (n <- nodes) {
//   assert (n.children.size() > 0) : "tighten() called on empty node!";
      val minCoords: Array[Float] = Array.ofDim[Float](numDims)
      val maxCoords: Array[Float] = Array.ofDim[Float](numDims)
      for (i <- 0 until numDims) {
        minCoords(i) = java.lang.Float.MAX_VALUE
        maxCoords(i) = -1.0f * java.lang.Float.MAX_VALUE
        for (c <- n.children) {
// so here we just enforce the child->parent relationship.
          c.parent = n
          if (c.coords(i) < minCoords(i)) {
            minCoords(i) = c.coords(i)
          }
          if ((c.coords(i) + c.dimensions(i)) > maxCoords(i)) {
            maxCoords(i) = (c.coords(i) + c.dimensions(i))
          }
        }
// we may have bulk-added a bunch of children to a node (eg. in
// splitNode)
// we may have bulk-added a bunch of children to a node (eg. in
// splitNode)
      }
      for (i <- 0 until numDims) {
// Convert max coords to dimensions
        maxCoords(i) -= minCoords(i)
      }
      System.arraycopy(minCoords, 0, n.coords, 0, numDims)
      System.arraycopy(maxCoords, 0, n.dimensions, 0, numDims)
    }
  } 
           
           
           
           
// chooseLeaf           
           
      def  chooseLeaf(){
        if (n.leaf) {
      n
    }
        val minInc: Float = java.lang.Float.MAX_VALUE
        val next: Node = null
         for (c <- n.children) {
      val inc: Float = getRequiredExpansion(c.coords, c.dimensions, e)
      if (inc < minInc) {
        minInc = inc
        next = c
      } else if (inc == minInc) {
        var curArea: Float = 1.0f
        var thisArea: Float = 1.0f
        for (i <- 0 until c.dimensions.length) {
          curArea *= next.dimensions(i)
          thisArea *= c.dimensions(i)
        }
        if (thisArea < curArea) {
          next = c
        }
      }
    }
        chooseLeaf(next, e)
      }    
           
           
           
           
           /**
     * Returns the increase in area necessary for the given rectangle to cover the
     * given entry.
     */
          private def getRequiredExpansion(coords: Array[Float],
                                   dimensions: Array[Float],
                                   e: Node): Float = {
    val area: Float = getArea(dimensions)
    val deltas: Array[Float] = Array.ofDim[Float](dimensions.length)
    for (i <- 0 until deltas.length) {
      if (coords(i) + dimensions(i) < e.coords(i) + e.dimensions(i)) {
        deltas(i) = e.coords(i) + e.dimensions(i) - coords(i) - dimensions(i)
      } else if (coords(i) + dimensions(i) > e.coords(i) + e.dimensions(i)) {
        deltas(i) = coords(i) - e.coords(i)
      }
    }
    var expanded: Float = 1.0f
    for (i <- 0 until dimensions.length) {
      expanded *= dimensions(i) + deltas(i)
    }
    (expanded - area)
  }

private def getArea(dimensions: Array[Float]): Float = {
    var area: Float = 1.0f
    for (i <- 0 until dimensions.length) {
      area *= dimensions(i)
    }
    area
  }
        
          
          private def isOverlap(scoords: Array[Float],
                        sdimensions: Array[Float],
                        coords: Array[Float],
                        dimensions: Array[Float]): Boolean = {
    val FUDGE_FACTOR: Float = 1.001f
    for (i <- 0 until scoords.length) {
      var overlapInThisDimension: Boolean = false
      if (scoords(i) == coords(i)) {
        overlapInThisDimension = true
      } else if (scoords(i) < coords(i)) {
        if (scoords(i) + FUDGE_FACTOR * sdimensions(i) >= coords(i)) {
          overlapInThisDimension = true
        }
      } else if (scoords(i) > coords(i)) {
        if (coords(i) + FUDGE_FACTOR * dimensions(i) >= scoords(i)) {
          overlapInThisDimension = true
        }
      }
      if (!overlapInThisDimension) {
        false
      }
    }
    true
  }

}
  
  class Node (coords: Array[Float],dimensions: Array[Float],val leaf: Boolean) {

private var root: Node = _
    
    // val coords: Array[Float] = new Array[Float](coords.length)

// val dimensions: Array[Float] = new Array[Float](dimensions.length)

val children: LinkedList[Node] = new LinkedList[Node]()

var parent: Node = _

System.arraycopy(coords, 0, this.coords, 0, coords.length)

System.arraycopy(dimensions, 0, this.dimensions, 0, dimensions.length)

}
   
  private class Entry(coords: Array[Float],
                      dimensions: Array[Float],
                      val entry: T)
      extends Node(coords,dimensions,true) {

override def toString(): String = "Entry: " + entry

}

[ + ] Show input
Compilation time: 1.26 sec, absolute service time: 1,3 sec

Error(s), warning(s):

source_file.scala:96: error: not found: type T
   def search(coords: Array[Float], dimensions: Array[Float]): List[T] = {
                                                                    ^
source_file.scala:99: error: not found: type T
    val results: LinkedList[T] = new LinkedList[T]()
                            ^
source_file.scala:99: error: not found: type T
    val results: LinkedList[T] = new LinkedList[T]()
                                                ^
source_file.scala:107: error: not found: type T
                     results: LinkedList[T]): Unit = {
                                         ^
source_file.scala:111: error: value coords is not a member of RTree.Node
           if isOverlap(coords, dimensions, e.coords, e.dimensions)) {
                                              ^
source_file.scala:111: error: value dimensions is not a member of RTree.Node
           if isOverlap(coords, dimensions, e.coords, e.dimensions)) {
                                                        ^
source_file.scala:116: error: value coords is not a member of RTree.Node
           if isOverlap(coords, dimensions, c.coords, c.dimensions)) {
                                              ^
source_file.scala:116: error: value dimensions is not a member of RTree.Node
           if isOverlap(coords, dimensions, c.coords, c.dimensions)) {
                                                        ^
source_file.scala:133: error: not found: type T
             entry: T): Boolean = {
                    ^
source_file.scala:165: error: not found: type T
  def findLeaf(n: Node,coords: Array[Float],dimensions: Array[Float],entry: T): Node ={
                                                                            ^
source_file.scala:143: error: not found: type T
    var removed: T = null
                 ^
source_file.scala:650: error: not found: type T
                      val entry: T)
                                 ^
source_file.scala:153: error: Unit does not take parameters
      condenseTree(l) { size -= 1; size + 1 }
                      ^
source_file.scala:162: error: not found: type T
      def delete(coords: Array[Float], entry: T): Boolean =    delete(coords, pointDims, entry)
                                              ^
source_file.scala:173: error: value coords is not a member of RTree.Node
           if isOverlap(c.coords, c.dimensions, coords, dimensions)) {
                          ^
source_file.scala:173: error: value dimensions is not a member of RTree.Node
           if isOverlap(c.coords, c.dimensions, coords, dimensions)) {
                                    ^
source_file.scala:204: error: reassignment to val
      n = n.parent
        ^
source_file.scala:260: error: not found: type T
        def insert(coords: Array[Float], entry: T): Unit = {
                                                ^
source_file.scala:238: error: not found: type T
     def insert(coords: Array[Float], dimensions: Array[Float], entry: T): Unit = {
                                                                       ^
source_file.scala:216: error: value coords is not a member of RTree.Entry
      insert(e.coords, e.dimensions, e.entry)
               ^
source_file.scala:216: error: value dimensions is not a member of RTree.Entry
      insert(e.coords, e.dimensions, e.entry)
                         ^
source_file.scala:242: error: too many arguments for method chooseLeaf: ()Unit
    val l: Node = chooseLeaf(root, e)
                            ^
source_file.scala:243: error: Boolean does not take parameters
    l.children.add(e) { size += 1; size - 1 }
                      ^
source_file.scala:264: error: not found: type T
        def visit(nv: NodeVisitor[T]): Unit = {
                                  ^
source_file.scala:276: error: value coords is not a member of RTree.Node
      System.arraycopy(currentNode.coords, 0, coordBuf, 0, numDims)
                                   ^
source_file.scala:277: error: value dimensions is not a member of RTree.Node
      System.arraycopy(currentNode.dimensions, 0, dimBuf, 0, numDims)
                                   ^
source_file.scala:336: error: value coords is not a member of RTree.Node
    val nn: Array[Node] = Array(n, new Node(n.coords, n.dimensions, n.leaf))
                                              ^
source_file.scala:336: error: value dimensions is not a member of RTree.Node
    val nn: Array[Node] = Array(n, new Node(n.coords, n.dimensions, n.leaf))
                                                        ^
source_file.scala:448: error: not found: type T
 def lPickSeeds ( nn: LinkedList[Node],T:Array[Node],f: RTree[T] => Unit): Unit ={
                                                              ^
source_file.scala:344: error: not enough arguments for method qPickSeeds: (nn: java.util.LinkedList[RTree.Node], T: Array[RTree.Node], f: RTree.SeedPicker.RTree[T] => Unit)Unit.
Unspecified value parameters T, f.
      if (seedPicker == SeedPicker.LINEAR) lPickSeeds(cc) else qPickSeeds(cc)
                                                                         ^
source_file.scala:347: error: type mismatch;
 found   : Array[RTree.Node]
 required: RTree.Node
    tighten(nn)
            ^
source_file.scala:353: error: type mismatch;
 found   : Array[RTree.Node]
 required: RTree.Node
        tighten(nn)
                ^
source_file.scala:359: error: type mismatch;
 found   : Array[RTree.Node]
 required: RTree.Node
        tighten(nn)
                ^
source_file.scala:366: error: value coords is not a member of RTree.Node
      val e0: Float = getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
                                                 ^
source_file.scala:366: error: value dimensions is not a member of RTree.Node
      val e0: Float = getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
                                                               ^
source_file.scala:367: error: value coords is not a member of RTree.Node
      val e1: Float = getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
                                                 ^
source_file.scala:367: error: value dimensions is not a member of RTree.Node
      val e1: Float = getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
                                                               ^
source_file.scala:373: error: value dimensions is not a member of RTree.Node
        val a0: Float = getArea(nn(0).dimensions)
                                      ^
source_file.scala:374: error: value dimensions is not a member of RTree.Node
        val a1: Float = getArea(nn(1).dimensions)
                                      ^
source_file.scala:396: error: type mismatch;
 found   : Int(2)
 required: RTree.Node
            val bestPair: Array[Node] = Array(2)
                                              ^
source_file.scala:400: error: value dimensions is not a member of RTree.Node
                 var n1a: Float = getArea(n1.dimensions)
                                             ^
source_file.scala:401: error: value dimensions is not a member of RTree.Node
                 var n2a: Float = getArea(n1.dimensions)
                                             ^
source_file.scala:405: error: value coords is not a member of RTree.Node
                   var jc0: Float = Math.min(n1.coords(i), n2.coords(i))
                                                ^
source_file.scala:405: error: value coords is not a member of RTree.Node
                   var jc0: Float = Math.min(n1.coords(i), n2.coords(i))
                                                              ^
source_file.scala:406: error: value coords is not a member of RTree.Node
                   var jc1: Float =Math.max(n1.coords(i) + n1.dimensions(i), n2.coords(i) + n2.dimensions(i))
                                               ^
source_file.scala:406: error: value dimensions is not a member of RTree.Node
                   var jc1: Float =Math.max(n1.coords(i) + n1.dimensions(i), n2.coords(i) + n2.dimensions(i))
                                                              ^
source_file.scala:406: error: value coords is not a member of RTree.Node
                   var jc1: Float =Math.max(n1.coords(i) + n1.dimensions(i), n2.coords(i) + n2.dimensions(i))
                                                                                ^
source_file.scala:406: error: value dimensions is not a member of RTree.Node
                   var jc1: Float =Math.max(n1.coords(i) + n1.dimensions(i), n2.coords(i) + n2.dimensions(i))
                                                                                               ^
source_file.scala:432: error: value coords is not a member of RTree.Node
        getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
                                   ^
source_file.scala:432: error: value dimensions is not a member of RTree.Node
        getRequiredExpansion(nn(0).coords, nn(0).dimensions, c)
                                                 ^
source_file.scala:434: error: value coords is not a member of RTree.Node
        getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
                                   ^
source_file.scala:434: error: value dimensions is not a member of RTree.Node
        getRequiredExpansion(nn(1).coords, nn(1).dimensions, c)
                                                 ^
source_file.scala:460: error: value coords is not a member of RTree.Node
        if (n.coords(i) < dimLb) {
              ^
source_file.scala:461: error: value coords is not a member of RTree.Node
          dimLb = n.coords(i)
                    ^
source_file.scala:463: error: value dimensions is not a member of RTree.Node
        if (n.dimensions(i) + n.coords(i) > dimUb) {
              ^
source_file.scala:463: error: value coords is not a member of RTree.Node
        if (n.dimensions(i) + n.coords(i) > dimUb) {
                                ^
source_file.scala:464: error: value dimensions is not a member of RTree.Node
          dimUb = n.dimensions(i) + n.coords(i)
                    ^
source_file.scala:464: error: value coords is not a member of RTree.Node
          dimUb = n.dimensions(i) + n.coords(i)
                                      ^
source_file.scala:466: error: value coords is not a member of RTree.Node
        if (n.coords(i) > dimMaxLb) {
              ^
source_file.scala:467: error: value coords is not a member of RTree.Node
          dimMaxLb = n.coords(i)
                       ^
source_file.scala:470: error: value dimensions is not a member of RTree.Node
        if (n.dimensions(i) + n.coords(i) < dimMinUb) {
              ^
source_file.scala:470: error: value coords is not a member of RTree.Node
        if (n.dimensions(i) + n.coords(i) < dimMinUb) {
                                ^
source_file.scala:471: error: value dimensions is not a member of RTree.Node
          dimMinUb = n.dimensions(i) + n.coords(i)
                       ^
source_file.scala:471: error: value coords is not a member of RTree.Node
          dimMinUb = n.dimensions(i) + n.coords(i)
                                         ^
source_file.scala:477: error: not found: value nMaxLb
      if ((nMaxLb == nMinUb)) -1.0f
           ^
source_file.scala:477: error: not found: value nMinUb
      if ((nMaxLb == nMinUb)) -1.0f
                     ^
source_file.scala:478: error: not found: value dimMinUb
      else Math.abs((dimMinUb - dimMaxLb) / (dimUb - dimLb))
                     ^
source_file.scala:478: error: not found: value dimMaxLb
      else Math.abs((dimMinUb - dimMaxLb) / (dimUb - dimLb))
                                ^
source_file.scala:478: error: not found: value dimUb
      else Math.abs((dimMinUb - dimMaxLb) / (dimUb - dimLb))
                                             ^
source_file.scala:478: error: not found: value dimLb
      else Math.abs((dimMinUb - dimMaxLb) / (dimUb - dimLb))
                                                     ^
source_file.scala:480: error: not found: value bestPair
      bestPair(0) = nMaxLb
      ^
source_file.scala:480: error: not found: value nMaxLb
      bestPair(0) = nMaxLb
                    ^
source_file.scala:481: error: not found: value bestPair
      bestPair(1) = nMinUb
      ^
source_file.scala:481: error: not found: value nMinUb
      bestPair(1) = nMinUb
                    ^
source_file.scala:482: error: reassignment to val
      bestSep = sep
              ^
source_file.scala:483: error: reassignment to val
      foundBestPair = true
                    ^
source_file.scala:487: error: not found: value bestPair
      bestPair = Array(nn.get(0), nn.get(1))
      ^
source_file.scala:489: error: not found: value bestPair
    nn.remove(bestPair(0))
              ^
source_file.scala:490: error: not found: value bestPair
    nn.remove(bestPair(1))
              ^
source_file.scala:491: error: not found: value bestPair
    bestPair
    ^
source_file.scala:516: error: value coords is not a member of RTree.Node
          if (c.coords(i) < minCoords(i)) {
                ^
source_file.scala:517: error: value coords is not a member of RTree.Node
            minCoords(i) = c.coords(i)
                             ^
source_file.scala:519: error: value coords is not a member of RTree.Node
          if ((c.coords(i) + c.dimensions(i)) > maxCoords(i)) {
                 ^
source_file.scala:519: error: value dimensions is not a member of RTree.Node
          if ((c.coords(i) + c.dimensions(i)) > maxCoords(i)) {
                               ^
source_file.scala:520: error: value coords is not a member of RTree.Node
            maxCoords(i) = (c.coords(i) + c.dimensions(i))
                              ^
source_file.scala:520: error: value dimensions is not a member of RTree.Node
            maxCoords(i) = (c.coords(i) + c.dimensions(i))
                                            ^
source_file.scala:532: error: value coords is not a member of RTree.Node
      System.arraycopy(minCoords, 0, n.coords, 0, numDims)
                                       ^
source_file.scala:533: error: value dimensions is not a member of RTree.Node
      System.arraycopy(maxCoords, 0, n.dimensions, 0, numDims)
                                       ^
source_file.scala:543: error: not found: value n
        if (n.leaf) {
            ^
source_file.scala:544: error: not found: value n
      n
      ^
source_file.scala:548: error: not found: value n
         for (c <- n.children) {
                   ^
source_file.scala:549: error: not found: value e
      val inc: Float = getRequiredExpansion(c.coords, c.dimensions, e)
                                                                    ^
source_file.scala:551: error: reassignment to val
        minInc = inc
               ^
source_file.scala:552: error: reassignment to val
        next = c
             ^
source_file.scala:557: error: value dimensions is not a member of RTree.Node
          curArea *= next.dimensions(i)
                          ^
source_file.scala:561: error: reassignment to val
          next = c
               ^
source_file.scala:565: error: too many arguments for method chooseLeaf: ()Unit
        chooseLeaf(next, e)
                  ^
source_file.scala:581: error: value coords is not a member of RTree.Node
      if (coords(i) + dimensions(i) < e.coords(i) + e.dimensions(i)) {
                                        ^
source_file.scala:581: error: value dimensions is not a member of RTree.Node
      if (coords(i) + dimensions(i) < e.coords(i) + e.dimensions(i)) {
                                                      ^
source_file.scala:582: error: value coords is not a member of RTree.Node
        deltas(i) = e.coords(i) + e.dimensions(i) - coords(i) - dimensions(i)
                      ^
104 errors found