import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
@Override
public double distance(ItemBoundable b1, ItemBoundable b2) {
    FacetSequence fs1 = (FacetSequence) b1.getItem();
    FacetSequence fs2 = (FacetSequence) b2.getItem();
    this.minDist = Double.MAX_VALUE;
    return this.distance(fs1, fs2);
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
@Override
public double distance(ItemBoundable item1, ItemBoundable item2) {
    FacetSequence fs1 = (FacetSequence) item1.getItem();
    FacetSequence fs2 = (FacetSequence) item2.getItem();
    return fs1.distance(fs2);
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
private void writeItemBoundable(Kryo kryo, Output output, ItemBoundable itemBoundable){
    geometrySerde.write(kryo, output, itemBoundable.getBounds());
    geometrySerde.write(kryo, output, itemBoundable.getItem());
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
private ItemBoundable readItemBoundable(Kryo kryo, Input input) {
    return new ItemBoundable(
            geometrySerde.read(kryo, input, Envelope.class),
            geometrySerde.read(kryo, input, Geometry.class)
    );
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
public double distance(ItemBoundable item1, ItemBoundable item2) {
    FacetSequence fs1 = (FacetSequence) item1.getItem();
    FacetSequence fs2 = (FacetSequence) item2.getItem();
    return fs1.distance(fs2);
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
public double distance(ItemBoundable b1, ItemBoundable b2) {
    FacetSequence fs1 = (FacetSequence) b1.getItem();
    FacetSequence fs2 = (FacetSequence) b2.getItem();
    minDist = Double.MAX_VALUE;
    return distance(fs1, fs2);
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
/**
 * Retrieve all the trees envelopes that intersect the geometry.
 *
 * @param checkGeom the {@link com.vividsolutions.jts.geom.Geometry} to use to check.
 * @param doOnlyEnvelope check for the geom envelope instead of a intersection with it.
 * @param minMaxZ an array to be filled with the min and max z to be used as style.
 * @return the list of envelopes contained in the supplied geometry.
 * @throws Exception
 */
@Override
public synchronized List<Geometry> getEnvelopesInGeometry( Geometry checkGeom, boolean doOnlyEnvelope, double[] minMaxZ )
        throws Exception {
    checkOpen();
    ArrayList<Geometry> envelopeListForTile = new ArrayList<Geometry>();

    Envelope env = checkGeom.getEnvelopeInternal();
    PreparedGeometry preparedGeometry = null;
    if (!doOnlyEnvelope) {
        preparedGeometry = PreparedGeometryFactory.prepare(checkGeom);
    }
    double min = Double.POSITIVE_INFINITY;
    double max = Double.NEGATIVE_INFINITY;
    List< ? > filesList = mainLasFolderIndex.query(env);
    for( Object fileName : filesList ) {
        if (fileName instanceof String) {
            String name = (String) fileName;
            File lasFile = new File(lasFolder, name);
            File lasIndexFile = FileUtilities.substituteExtention(lasFile, "lasfix");

            String absolutePath = lasIndexFile.getAbsolutePath();
            STRtreeJGT lasIndex = fileName2IndexMap.get(absolutePath);
            if (lasIndex == null) {
                lasIndex = OmsLasIndexReader.readIndex(absolutePath);
                fileName2IndexMap.put(absolutePath, lasIndex);
            }
            List< ? > queryBoundables = lasIndex.queryBoundables(env);
            for( Object object : queryBoundables ) {
                if (object instanceof ItemBoundable) {
                    ItemBoundable itemBoundable = (ItemBoundable) object;
                    double[] item = (double[]) itemBoundable.getItem();
                    if (item.length > 0) {
                        Envelope bounds = (Envelope) itemBoundable.getBounds();
                        Polygon envelopePolygon = LasIndexer.envelopeToPolygon(bounds);
                        envelopePolygon.setUserData(new double[]{item[2], item[3]});
                        if (minMaxZ != null) {
                            min = Math.min(min, item[2]);
                            max = Math.max(max, item[2]);
                        }
                        if (doOnlyEnvelope) {
                            envelopeListForTile.add(envelopePolygon);
                        } else {
                            if (preparedGeometry.intersects(envelopePolygon)) {
                                envelopeListForTile.add(envelopePolygon);
                            }
                        }
                    }
                }
            }
        }
    }
    if (minMaxZ != null) {
        minMaxZ[0] = min;
        minMaxZ[1] = max;
    }
    return envelopeListForTile;
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
public double distance(ItemBoundable item1, ItemBoundable item2) {
  FacetSequence fs1 = (FacetSequence) item1.getItem();
  FacetSequence fs2 = (FacetSequence) item2.getItem();
  return fs1.distance(fs2);    
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
public double distance(ItemBoundable b1, ItemBoundable b2) {
  FacetSequence fs1 = (FacetSequence) b1.getItem();
  FacetSequence fs2 = (FacetSequence) b2.getItem();
  minDist = Double.MAX_VALUE;
  return distance(fs1, fs2);
}
 

import com.vividsolutions.jts.index.strtree.ItemBoundable; //导入依赖的package包/类
/**
 * Computes the distance between the {@link com.vividsolutions.jts.index.strtree.Boundable}s in this pair.
 * The boundables are either composites or leaves.
 * If either is composite, the distance is computed as the minimum distance
 * between the bounds.
 * If both are leaves, the distance is computed by {@link #itemDistance(com.vividsolutions.jts.index.strtree.ItemBoundable, com.vividsolutions.jts.index.strtree.ItemBoundable)}.
 * 
 * @return
 */
private double distance() {
    // if items, compute exact distance
    if (isLeaves()) {
        return itemDistance.distance((ItemBoundable) boundable1, (ItemBoundable) boundable2);
    }
    // otherwise compute distance between bounds of boundables
    return ((Envelope) boundable1.getBounds()).distance(((Envelope) boundable2.getBounds()));
}