import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
/**
 * Finds the closest node or edges within the specified maximum radius.
 *
 * @param x          the x position of the query point
 * @param y          the y position of the query point
 * @param nodeAction the action that needs to be executed when a node is found
 * @param edgeAction the action that needs to be executed when an edge is found
 */
@SuppressWarnings("squid:S1166") // No need to log the exception itself, a message is enough.
public void find(final double x, final double y,
                 final Consumer<Integer> nodeAction, final BiConsumer<Integer, Integer> edgeAction) {
    try {
        final Entry<Integer[], Geometry> result = tree.nearest(point(x, y), MAX_NEARNESS_DISTANCE, 1)
                .toBlocking()
                .first();

        if (result.geometry() instanceof Rectangle) {
            nodeAction.accept(result.value()[0]);
        } else if (result.geometry() instanceof Line) {
            edgeAction.accept(result.value()[0], result.value()[1]);
        }
    } catch (final NoSuchElementException e) {
        // There is no need to log the exception itself.
        LOGGER.debug("No node or edge found at position (" + x + ", " + y + ").");
    }
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
static List<Entry<Object, Rectangle>> entries1000() {
    List<Entry<Object, Rectangle>> list = new ArrayList<Entry<Object, Rectangle>>();
    BufferedReader br = new BufferedReader(
            new InputStreamReader(RTreeBenchmark.class.getResourceAsStream("/1000.txt")));
    String line;
    try {
        while ((line = br.readLine()) != null) {
            String[] items = line.split(" ");
            double x = Double.parseDouble(items[0]);
            double y = Double.parseDouble(items[1]);
            list.add(Entries.entry(new Object(), Geometries.rectangle(x, y, x + 1, y + 1)));
        }
        br.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return list;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@Override
public boolean place(final Word word) {
    final Rectangle wordRectangle = Geometries.rectangle(
            word.getPosition().getX(),
            word.getPosition().getY(),
            word.getPosition().getX() + word.getDimension().getWidth(),
            word.getPosition().getY() + word.getDimension().getHeight());

    final Observable<Entry<String, Rectangle>> results = placedWordRTree.search(
            wordRectangle);

    final int matches = results.count().toBlocking().single();
    if (matches > 0) {
        return false;
    }
    placedWordRTree = placedWordRTree.add(word.getWord(), wordRectangle);
    return true;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
/**
 * Find.
 *
 * @param longitude the longitude
 * @param latitude the latitude
 * @return the city
 */
public City find(Double longitude, Double latitude){
	if(longitude == null || latitude == null){
		return null;
	}
	Observable<Entry<City, Geometry>> result =  this.rtree.nearest(Geometries.pointGeographic(longitude, latitude), 10000, 1);
	if(result==null){
		return null;
	}
	try{
		return result.toBlocking().single().value();
	}catch(NoSuchElementException e){
		return null;
	}
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
/**
 * @return all tiles that intersect the specified bounding box.
 */
public List<TileBounds> findTilesInBox(final double minX,
                                       final double minY,
                                       final double maxX,
                                       final double maxY) {

    final Rectangle rectangle = Geometries.rectangle(minX, minY, maxX, maxY);
    final Observable<Entry<TileBounds, Geometry>> searchResults = tree.search(rectangle);
    return convertResultsToList(searchResults);
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@Test
public void testRTree() {
    RTree<String> rtree = RTree.create();
    rtree = rtree.add("foo", closed(10, 20));
    rtree = rtree.add("bar", closedOpen(14, 28));
    rtree = rtree.add("baz", open(18, 36));

    int count = 0;
    for (Entry<String> result : rtree.search(singleton(20)).toBlocking().toIterable()) {
        count++;
    }
    assertEquals(3, count);
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
static List<Entry<Object, Point>> entriesList() {
    List<Entry<Object, Point>> result = entries().toList().toBlocking().single();
    System.out.println("loaded greek earthquakes into list");
    return result;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@GenerateMicroBenchmark
public RTree<Object, Point> insertBatchGreek() {
    RTree<Object, Point> tree = rtreeGreek;
    for (Entry<Object, Point> entry: entriesGreek04) tree = tree.add(entry);
    return tree;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@GenerateMicroBenchmark
public RTree<Object, Rectangle> insertBatch1k() {
    RTree<Object, Rectangle> tree = rtree1k;
    for (Entry<Object, Rectangle> entry: entries1k04) tree = tree.add(entry);
    return tree;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@GenerateMicroBenchmark
public RTree<Object, Point> deleteBatchGreek() {
    RTree<Object, Point> tree = rtreeGreek;
    for (Entry<Object, Point> entry: entriesGreek06) tree = tree.delete(entry);
    return tree;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
@GenerateMicroBenchmark
public RTree<Object, Rectangle> deleteBatch1k() {
    RTree<Object, Rectangle> tree = rtree1k;
    for (Entry<Object, Rectangle> entry: entries1k06) tree = tree.delete(entry);
    return tree;
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
protected void joinGroupedShapes() {
	
	// find groups of shapes that are visually together
	// - Must overlap
	// - Must be same type
	// - Must not contain each other
	// - Only one must have text
	
	// we can't actually make a group here, as that makes things like
	// bounding rectangles annoying. Instead, just link them together
	// with an edge 
	
	// insert naive implementation here
	for (final ShapeData shapeData: shapes) {
		
		if (shapeData.is1d())
			continue;
		
		final String symbolName = shapeData.vertex.getProperty("symbolName");
		if (symbolName.equals(""))
			continue;
		
		Observable<Entry<ShapeData, Rectangle>> entries = rtree.search(shapeData.rtreeBounds);
		
		entries.forEach(new Rx.RTreeAction() {

			@Override
			public void call(Entry<ShapeData, Rectangle> entry) {
				ShapeData other = entry.value();
				
				if (other == shapeData || other.is1d())
					return;
				
				// if the intersection is equal to the area of the smallest, then
				// we can assume one of them contains the other
				// .. don't want those to be joined
				
				if (!other.vertex.getProperty("symbolName").equals(symbolName) || 
					ShapeData.eitherEncloses(shapeData, other)) {
					return;
				}
				
				// but if it doesn't contain, then link them together
				createEdge(shapeData, other, "linked", null, null);
			}
		});
	}
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
protected void infer1dConnections(final ShapeData shapeData) {
	
	// create a list of things that I'm attached to
	final Set<Vertex> attached = Sets.newHashSet(shapeData.vertex.getVertices(Direction.BOTH));
	
	// identify any shapes that it overlaps with
	// add that shape to the list of connections
	Observable<Entry<ShapeData, Rectangle>> entries = rtree.search(shapeData.rtreeBounds);
	
	entries.subscribe(new Rx.RTreeSubscriber() {
		
		@Override
		public void onNext(Entry<ShapeData, Rectangle> e) {
			
			ShapeData other = e.value();
			
			if (other == shapeData || other.removed || !other.is1d() || attached.contains(other.vertex))
				return;
			
			// don't infer connections between lines of different colors
			// or different line patterns
			if (!shapeData.lineColor.equals(other.lineColor) || shapeData.linePattern != other.linePattern) {
				return;
			}
			
			// compute if they intersect
			List<Point2D> intersections = new ArrayList<>();
			
			if (!GeomUtils.findIntersections(shapeData.path1D, other.path1D, intersections, null)) {
				return;
			}
			
			// TODO
			// if they are both dynamic connectors, don't create connections
			// unless their intersection is at the end of a line?
			// alternatively, try to check if the intersection happens at an
			// 'arcto' point. if so, discard, as that's a 'clear' visual indicator
			// that it should not be connected
			
			// ok, we've gotten here, create a connection between the two lines
			// -> connection point is first point.. not sure what to do with other points
			Point2D intersection = intersections.get(0);
			createEdge(shapeData, other, "inferred-1d", intersection.getX(), intersection.getY());
		}
	});
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
/**
 * this takes a shape that is a 'textbox'
 */
protected void associateTextboxWithShape(final ShapeData textBox) {
	
	// limit the search to some reasonable number/distance (TODO: what is reasonable)
	
	Observable<Entry<ShapeData, Rectangle>> entries = SpatialTools.nearest(rtree, textBox.rtreeBounds, helper.textInferenceDistance(textBox), rtree.size());
	
	final List<ShapeData> maybe = new ArrayList<>();
	
	entries.subscribe(new Rx.RTreeSubscriber() {
		
		@Override
		public void onNext(Entry<ShapeData, Rectangle> e) {
			
			ShapeData other = e.value();
			
			if (other == textBox || other.hasText || other.removed || !helper.onTextInference(textBox, other))
				return;
			
			// if it encloses it, only associate if there's nothing else closer
			if (other.encloses(textBox)) {
				if (maybe.isEmpty())
					maybe.add(other);
				
				return;
			}
			
			doAssociateTextboxWithShape(textBox, other);
			maybe.clear();
			
			// TODO: probably want to be more intelligent, and assign the text to
			//       things that are nearer in a particular direction, taking 
			//       advantage of how a human might naturally align the text..
			
			// done with this
			unsubscribe();
		}
	});
	
	// if we didn't find any alternatives, associate the first one that enclosed
	if (!maybe.isEmpty())
		doAssociateTextboxWithShape(textBox, maybe.get(0));
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
protected void inferDisconnectedGroupConnections(final GroupData groupData, final List<ShapeData> connections, final boolean ignore1d) {
	// identify any shapes that the group overlaps with
	// add that shape to the list of connections
	Observable<Entry<ShapeData, Rectangle>> entries = rtree.search(groupData.group.rtreeBounds);
	
	final Path2D groupPath = groupData.group.getPath();
	
	entries.subscribe(new Rx.RTreeSubscriber() {

		@Override
		public void onNext(Entry<ShapeData, Rectangle> e) {
			
			ShapeData other = e.value();
			if (other == groupData.group)
				return;
			
			if (other.is1d()) {
				
				// TODO: what we probably want is a function that checks all segments of the path 
				//       -- but only matches on the end segments matching
				
				if (ignore1d)
					return;
				
				// check to see if one of the endpoints of the 1d shape intersects
				// with the group
				if (!GeomUtils.pathIntersects(groupPath, other.path1Dstart) &&
				    !GeomUtils.pathIntersects(groupPath, other.path1Dend)) {
					return;
				}
				
			} else {
				
				if (!other.vertex.getVertices(Direction.BOTH).iterator().hasNext() ||  
					!GeomUtils.pathIntersects(groupPath, other.path2D)) {
					return;
				}
			}
			
			connections.add(other);
		}
	});
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
protected void removeShape(ShapeData shapeData) {
	shapeData.removed = true;
	graph.removeVertex(shapeData.vertex);
	rtree = rtree.delete(new Entry<ShapeData, Rectangle>(shapeData, shapeData.rtreeBounds));
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
public static <T, S extends Geometry> Observable<Entry<T, S>> nearest(RTree<T, S> rtree, final Rectangle r, final double maxDistance, int maxCount) {
    return rtree.search(r, maxDistance).lift(
            new SortedOutputQueue<Entry<T, S>>(maxCount, Comparators
                    .<T, S> ascendingDistance(r)));
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
/**
 * @return all tiles that intersect the specified circle.
 */
public List<TileBounds> findTilesInCircle(final Circle circle) {
    final Observable<Entry<TileBounds, Geometry>> searchResults = tree.search(circle);
    return convertResultsToList(searchResults);
}
 

import com.github.davidmoten.rtree.Entry; //导入依赖的package包/类
private List<TileBounds> convertResultsToList(final Observable<Entry<TileBounds, Geometry>> searchResults) {

        final List<TileBounds> matchingTiles = new ArrayList<>();

        // TODO: make sure use of toBlocking() here is appropriate

        final List<Entry<TileBounds, Geometry>> collectedResultList = searchResults.toList().toBlocking().single();
        for (final Entry<TileBounds, Geometry> entry : collectedResultList) {
            matchingTiles.add(entry.value());
        }

        return matchingTiles;
    }