import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
/**
 * For a pair which is not a leaf
 * (i.e. has at least one composite boundable)
 * computes a list of new pairs
 * from the expansion of the larger boundable.
 */
public void expandToQueue(PriorityQueue priQ, double minDistance) {
    boolean isComp1 = isComposite(this.boundable1);
    boolean isComp2 = isComposite(this.boundable2);

    /**
     * HEURISTIC: If both boundable are composite,
     * choose the one with largest area to expand.
     * Otherwise, simply expand whichever is composite.
     */
    if (isComp1 && isComp2) {
        if (area(this.boundable1) > area(this.boundable2)) {
            this.expand(this.boundable1, this.boundable2, priQ, minDistance);
            return;
        } else {
            this.expand(this.boundable2, this.boundable1, priQ, minDistance);
            return;
        }
    } else if (isComp1) {
        this.expand(this.boundable1, this.boundable2, priQ, minDistance);
        return;
    } else if (isComp2) {
        this.expand(this.boundable2, this.boundable1, priQ, minDistance);
        return;
    }

    throw new IllegalArgumentException("neither boundable is composite");
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private void expand(Boundable bndComposite, Boundable bndOther,
                    PriorityQueue priQ, double minDistance) {
    List children = ((AbstractNode) bndComposite).getChildBoundables();
    for (Object aChildren : children) {
        Boundable child = (Boundable) aChildren;
        BoundablePair bp = new BoundablePair(child, bndOther, this.itemDistance);
        // only add to queue if this pair might contain the closest points
        // MD - it's actually faster to construct the object rather than called distance(child, bndOther)!
        if (bp.getDistance() < minDistance) {
            priQ.add(bp);
        }
    }
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
/**
 * For a pair which is not a leaf
 * (i.e. has at least one composite boundable)
 * computes a list of new pairs
 * from the expansion of the larger boundable.
 */
public void expandToQueue(PriorityQueue priQ, double minDistance) {
    boolean isComp1 = isComposite(boundable1);
    boolean isComp2 = isComposite(boundable2);

    /**
     * HEURISTIC: If both boundable are composite,
     * choose the one with largest area to expand.
     * Otherwise, simply expand whichever is composite.
     */
    if (isComp1 && isComp2) {
        if (area(boundable1) > area(boundable2)) {
            expand(boundable1, boundable2, priQ, minDistance);
            return;
        } else {
            expand(boundable2, boundable1, priQ, minDistance);
            return;
        }
    } else if (isComp1) {
        expand(boundable1, boundable2, priQ, minDistance);
        return;
    } else if (isComp2) {
        expand(boundable2, boundable1, priQ, minDistance);
        return;
    }

    throw new IllegalArgumentException("neither boundable is composite");
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private void expand(Boundable bndComposite, Boundable bndOther,
                    PriorityQueue priQ, double minDistance) {
    List children = ((AbstractNode) bndComposite).getChildBoundables();
    for (Iterator i = children.iterator(); i.hasNext(); ) {
        Boundable child = (Boundable) i.next();
        BoundablePair bp = new BoundablePair(child, bndOther, itemDistance);
        // only add to queue if this pair might contain the closest points
        // MD - it's actually faster to construct the object rather than called distance(child, bndOther)!
        if (bp.getDistance() < minDistance) {
            priQ.add(bp);
        }
    }
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
/**
 * For a pair which is not a leaf 
 * (i.e. has at least one composite boundable)
 * computes a list of new pairs 
 * from the expansion of the larger boundable.
 * 
 */
public void expandToQueue( PriorityQueue priQ, double minDistance ) {
    boolean isComp1 = isComposite(boundable1);
    boolean isComp2 = isComposite(boundable2);

    /**
     * HEURISTIC: If both boundable are composite,
     * choose the one with largest area to expand.
     * Otherwise, simply expand whichever is composite.
     */
    if (isComp1 && isComp2) {
        if (area(boundable1) > area(boundable2)) {
            expand(boundable1, boundable2, priQ, minDistance);
            return;
        } else {
            expand(boundable2, boundable1, priQ, minDistance);
            return;
        }
    } else if (isComp1) {
        expand(boundable1, boundable2, priQ, minDistance);
        return;
    } else if (isComp2) {
        expand(boundable2, boundable1, priQ, minDistance);
        return;
    }

    throw new IllegalArgumentException("neither boundable is composite");
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private void expand( Boundable bndComposite, Boundable bndOther, PriorityQueue priQ, double minDistance ) {
    List children = ((AbstractNode) bndComposite).getChildBoundables();
    for( Iterator i = children.iterator(); i.hasNext(); ) {
        Boundable child = (Boundable) i.next();
        BoundablePair bp = new BoundablePair(child, bndOther, itemDistance);
        // only add to queue if this pair might contain the closest points
        // MD - it's actually faster to construct the object rather than called distance(child,
        // bndOther)!
        if (bp.getDistance() < minDistance) {
            priQ.add(bp);
        }
    }
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
/**
 * For a pair which is not a leaf 
 * (i.e. has at least one composite boundable)
 * computes a list of new pairs 
 * from the expansion of the larger boundable.
 * 
 * @return a List of new pairs
 */
public void expandToQueue(PriorityQueue priQ, double minDistance)
{
  boolean isComp1 = isComposite(boundable1);
  boolean isComp2 = isComposite(boundable2);
  
  /**
   * HEURISTIC: If both boundable are composite,
   * choose the one with largest area to expand.
   * Otherwise, simply expand whichever is composite.
   */
  if (isComp1 && isComp2) {
    if (area(boundable1) > area(boundable2)) {
      expand(boundable1, boundable2, priQ, minDistance);
      return;
    }
    else {
      expand(boundable2, boundable1, priQ, minDistance);
      return;
    }
  }
  else if (isComp1) {
    expand(boundable1, boundable2, priQ, minDistance);
    return;
  }
  else if (isComp2) {
    expand(boundable2, boundable1, priQ, minDistance);
    return;
  }
  
  throw new IllegalArgumentException("neither boundable is composite");
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private void expand(Boundable bndComposite, Boundable bndOther,
    PriorityQueue priQ, double minDistance)
{
  List children = ((AbstractNode) bndComposite).getChildBoundables();
  for (Iterator i = children.iterator(); i.hasNext(); ) {
    Boundable child = (Boundable) i.next();
    BoundablePair bp = new BoundablePair(child, bndOther, itemDistance);
    // only add to queue if this pair might contain the closest points
    // MD - it's actually faster to construct the object rather than called distance(child, bndOther)!
    if (bp.getDistance() < minDistance) {
      priQ.add(bp);
    }
  }
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
/**
 * For a pair which is not a leaf 
 * (i.e. has at least one composite boundable)
 * computes a list of new pairs 
 * from the expansion of the larger boundable.
 * 
 */
public void expandToQueue(PriorityQueue priQ, double minDistance)
{
  boolean isComp1 = isComposite(boundable1);
  boolean isComp2 = isComposite(boundable2);
  
  /**
   * HEURISTIC: If both boundable are composite,
   * choose the one with largest area to expand.
   * Otherwise, simply expand whichever is composite.
   */
  if (isComp1 && isComp2) {
    if (area(boundable1) > area(boundable2)) {
      expand(boundable1, boundable2, priQ, minDistance);
      return;
    }
    else {
      expand(boundable2, boundable1, priQ, minDistance);
      return;
    }
  }
  else if (isComp1) {
    expand(boundable1, boundable2, priQ, minDistance);
    return;
  }
  else if (isComp2) {
    expand(boundable2, boundable1, priQ, minDistance);
    return;
  }
  
  throw new IllegalArgumentException("neither boundable is composite");
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private Object[] nearestNeighbour(BoundablePair initBndPair, double maxDistance) {
    double distanceLowerBound = maxDistance;
    BoundablePair minPair = null;

    // initialize internal structures
    PriorityQueue priQ = new PriorityQueue();

    // initialize queue
    priQ.add(initBndPair);

    while (!priQ.isEmpty() && distanceLowerBound > 0.0) {
        // pop head of queue and expand one side of pair
        BoundablePair bndPair = (BoundablePair) priQ.poll();
        double currentDistance = bndPair.getDistance();

        /**
         * If the distance for the first node in the queue
         * is >= the current minimum distance, all other nodes
         * in the queue must also have a greater distance.
         * So the current minDistance must be the true minimum,
         * and we are done.
         */
        if (currentDistance >= distanceLowerBound) {
            break;
        }

        /**
         * If the pair members are leaves
         * then their distance is the exact lower bound.
         * Update the distanceLowerBound to reflect this
         * (which must be smaller, due to the test
         * immediately prior to this).
         */
        if (bndPair.isLeaves()) {
            // assert: currentDistance < minimumDistanceFound
            distanceLowerBound = currentDistance;
            minPair = bndPair;
        } else {
            // testing - does allowing a tolerance improve speed?
            // Ans: by only about 10% - not enough to matter
    /*
    double maxDist = bndPair.getMaximumDistance();
    if (maxDist * .99 < lastComputedDistance) 
      return;
    //*/

            /**
             * Otherwise, expand one side of the pair,
             * (the choice of which side to expand is heuristically determined)
             * and insert the new expanded pairs into the queue
             */
            bndPair.expandToQueue(priQ, distanceLowerBound);
        }
    }
    // done - return items with min distance
    return new Object[] {
            ((ItemBoundable) minPair.getBoundable(0)).getItem(),
            ((ItemBoundable) minPair.getBoundable(1)).getItem()
    };
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private Object[] nearestNeighbour(BoundablePair initBndPair, double maxDistance) {
    double distanceLowerBound = maxDistance;
    BoundablePair minPair = null;

    // initialize internal structures
    PriorityQueue priQ = new PriorityQueue();

    // initialize queue
    priQ.add(initBndPair);

    while (!priQ.isEmpty() && distanceLowerBound > 0.0) {
        // pop head of queue and expand one side of pair
        BoundablePair bndPair = (BoundablePair) priQ.poll();
        double currentDistance = bndPair.getDistance();

        /**
         * If the distance for the first node in the queue
         * is >= the current minimum distance, all other nodes
         * in the queue must also have a greater distance.
         * So the current minDistance must be the true minimum,
         * and we are done.
         */
        if (currentDistance >= distanceLowerBound)
            break;

        /**
         * If the pair members are leaves
         * then their distance is the exact lower bound.
         * Update the distanceLowerBound to reflect this
         * (which must be smaller, due to the test
         * immediately prior to this).
         */
        if (bndPair.isLeaves()) {
            // assert: currentDistance < minimumDistanceFound
            distanceLowerBound = currentDistance;
            minPair = bndPair;
        } else {
            // testing - does allowing a tolerance improve speed?
            // Ans: by only about 10% - not enough to matter
    /*
    double maxDist = bndPair.getMaximumDistance();
    if (maxDist * .99 < lastComputedDistance) 
      return;
    //*/

            /**
             * Otherwise, expand one side of the pair,
             * (the choice of which side to expand is heuristically determined)
             * and insert the new expanded pairs into the queue
             */
            bndPair.expandToQueue(priQ, distanceLowerBound);
        }
    }
    // done - return items with min distance
    return new Object[]{
            ((ItemBoundable) minPair.getBoundable(0)).getItem(),
            ((ItemBoundable) minPair.getBoundable(1)).getItem()
    };
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private Object[] nearestNeighbour( BoundablePair initBndPair, double maxDistance ) {
    double distanceLowerBound = maxDistance;
    BoundablePair minPair = null;

    // initialize internal structures
    PriorityQueue priQ = new PriorityQueue();

    // initialize queue
    priQ.add(initBndPair);

    while( !priQ.isEmpty() && distanceLowerBound > 0.0 ) {
        // pop head of queue and expand one side of pair
        BoundablePair bndPair = (BoundablePair) priQ.poll();
        double currentDistance = bndPair.getDistance();

        /**
         * If the distance for the first node in the queue
         * is >= the current minimum distance, all other nodes
         * in the queue must also have a greater distance.
         * So the current minDistance must be the true minimum,
         * and we are done.
         */
        if (currentDistance >= distanceLowerBound)
            break;

        /**
         * If the pair members are leaves
         * then their distance is the exact lower bound.
         * Update the distanceLowerBound to reflect this
         * (which must be smaller, due to the test 
         * immediately prior to this). 
         */
        if (bndPair.isLeaves()) {
            // assert: currentDistance < minimumDistanceFound
            distanceLowerBound = currentDistance;
            minPair = bndPair;
        } else {
            // testing - does allowing a tolerance improve speed?
            // Ans: by only about 10% - not enough to matter
            /*
            double maxDist = bndPair.getMaximumDistance();
            if (maxDist * .99 < lastComputedDistance) 
              return;
            //*/

            /**
             * Otherwise, expand one side of the pair,
             * (the choice of which side to expand is heuristically determined) 
             * and insert the new expanded pairs into the queue
             */
            bndPair.expandToQueue(priQ, distanceLowerBound);
        }
    }
    // done - return items with min distance
    return new Object[]{((ItemBoundable) minPair.getBoundable(0)).getItem(),
            ((ItemBoundable) minPair.getBoundable(1)).getItem()};
}
 

import com.vividsolutions.jts.util.PriorityQueue; //导入依赖的package包/类
private Object[] nearestNeighbour(BoundablePair initBndPair, double maxDistance) 
{
  double distanceLowerBound = maxDistance;
  BoundablePair minPair = null;
  
  // initialize internal structures
  PriorityQueue priQ = new PriorityQueue();

  // initialize queue
  priQ.add(initBndPair);

  while (! priQ.isEmpty() && distanceLowerBound > 0.0) {
    // pop head of queue and expand one side of pair
    BoundablePair bndPair = (BoundablePair) priQ.poll();
    double currentDistance = bndPair.getDistance();
    
    /**
     * If the distance for the first node in the queue
     * is >= the current minimum distance, all other nodes
     * in the queue must also have a greater distance.
     * So the current minDistance must be the true minimum,
     * and we are done.
     */
    if (currentDistance >= distanceLowerBound) 
      break;  

    /**
     * If the pair members are leaves
     * then their distance is the exact lower bound.
     * Update the distanceLowerBound to reflect this
     * (which must be smaller, due to the test 
     * immediately prior to this). 
     */
    if (bndPair.isLeaves()) {
      // assert: currentDistance < minimumDistanceFound
      distanceLowerBound = currentDistance;
      minPair = bndPair;
    }
    else {
      // testing - does allowing a tolerance improve speed?
      // Ans: by only about 10% - not enough to matter
      /*
      double maxDist = bndPair.getMaximumDistance();
      if (maxDist * .99 < lastComputedDistance) 
        return;
      //*/

      /**
       * Otherwise, expand one side of the pair,
       * (the choice of which side to expand is heuristically determined) 
       * and insert the new expanded pairs into the queue
       */
      bndPair.expandToQueue(priQ, distanceLowerBound);
    }
  }
  // done - return items with min distance
  return new Object[] {    
        ((ItemBoundable) minPair.getBoundable(0)).getItem(),
        ((ItemBoundable) minPair.getBoundable(1)).getItem()
    };
}