v1.2

完成最邻近搜索功能

Author: codingmiao

README.md

@@ -16,7 +16,7 @@ Node node = tx.createNode(testLabel);//新建节点
 Point geo = wkbReader.read("POINT(10 20)");
 byte[] wkb = wkbWriter.write(geo);//转为wkb
 node.setProperty("geometry", wkb);//设置空间字段值,必须为wkb格式
-rTreeIndex.add(node,tx);//加入索引
+rTreeIndex.add(node,tx);//加入索引(效率起见，多个node的话用list add，详见测试用例)
 
 ~~~
 
@@ -43,9 +43,21 @@ try (Transaction tx = db.beginTx()) {
 
 最邻近搜索
 ~~~java
-施工中...
+//查询距离点(10.2, 13.2)最近的5个node
+try (Transaction tx = db.beginTx()) {
+    List<DistanceResult> res = RtreeNearestQuery.queryNearestN(tx, rTreeIndex, 10.2, 13.2, 5, (node, geometry) -> true);
+    System.out.println(res);
+}
 
 ~~~
+~~~java
+//查询满足约束条件且距离点(10.2, 13.2)最近的5个node
+try (Transaction tx = db.beginTx()) {
+    List<DistanceResult> res = RtreeNearestQuery.queryNearestN(tx, rTreeIndex, 10.2, 13.2, 5, (node, geometry) -> geometry.getCoordinate().x<10);
+    System.out.println(res);//DistanceResult里包含了node、距离以及geometry，详见测试用例
+}
+~~~
+
 
 
 ## install
@@ -56,7 +68,7 @@ maven import in your project
 <dependency>
     <groupId>org.wowtools</groupId>
     <artifactId>neo4j-rtree</artifactId>
-    <version>1.1</version>
+    <version>1.2</version>
 </dependency>
 ```
 注意，maven中央库的依赖用jdk11编译，所以如果你的项目使用了jdk8，你需要自己编译一份适合于你的jdk的:

pom.xml

@@ -12,7 +12,7 @@
     </properties>
     <groupId>org.wowtools</groupId>
     <artifactId>neo4j-rtree</artifactId>
-    <version>1.1</version>
+    <version>1.2</version>
     <name>neo4j-rtree</name>
 
     <description>a spatial index for neo4j 4.x.</description>

src/main/java/org/wowtools/neo4j/rtree/RtreeNearestQuery.java

@@ -1,9 +1,16 @@
 package org.wowtools.neo4j.rtree;
 
+import org.locationtech.jts.geom.Geometry;
 import org.neo4j.graphdb.Node;
 import org.neo4j.graphdb.Transaction;
+import org.wowtools.neo4j.rtree.nearest.DistanceResult;
+import org.wowtools.neo4j.rtree.nearest.NearestNeighbour;
 import org.wowtools.neo4j.rtree.spatial.RTreeIndex;
 
+import java.util.List;
+
+import static org.bouncycastle.asn1.x500.style.RFC4519Style.dc;
+
 /**
  * @author liuyu
  * @date 2020/6/10
@@ -21,7 +28,7 @@ public interface NodeFilter {
          * @param node 节点
          * @return 返回false则忽略此节点
          */
-        boolean accept(Node node);
+        boolean accept(Node node, Geometry geometry);
     }
 
     /**
@@ -35,6 +42,10 @@ public interface NodeFilter {
      * @param n          最大返回node数
      * @param nodeFilter 节点过滤器
      */
-    public static void queryNearestN(Transaction tx, RTreeIndex rTreeIndex, double x, double y, int n, NodeFilter nodeFilter) {
+    public static List<DistanceResult> queryNearestN(Transaction tx, RTreeIndex rTreeIndex, double x, double y, int n, NodeFilter nodeFilter) {
+        Node rtreeNode = rTreeIndex.getIndexRoot(tx);
+        NearestNeighbour nn =
+                new NearestNeighbour(nodeFilter, n, rtreeNode, x, y, rTreeIndex.getGeometryFieldName());
+        return nn.find();
     }
 }

src/main/java/org/wowtools/neo4j/rtree/nearest/DistanceResult.java

@@ -0,0 +1,43 @@
+package org.wowtools.neo4j.rtree.nearest;
+
+import org.locationtech.jts.geom.Geometry;
+import org.neo4j.graphdb.Node;
+
+/**
+ * 距离查询结果
+ *
+ * @author liuyu
+ * @date 2020/6/12
+ */
+public class DistanceResult {
+    private final Node t;
+    private final double dist;
+    private final Geometry geometry;
+
+    public DistanceResult(Node t, double dist, Geometry geometry) {
+        this.t = t;
+        this.dist = dist;
+        this.geometry = geometry;
+    }
+
+    public Node getNode() {
+        return t;
+    }
+
+    public double getDist() {
+        return dist;
+    }
+
+    public Geometry getGeometry() {
+        return geometry;
+    }
+
+    @Override
+    public String toString() {
+        return "DistanceResult{" +
+                "node=" + t.getId() +
+                ", dist=" + dist +
+                ", geometry=" + geometry.toText() +
+                '}';
+    }
+}

src/main/java/org/wowtools/neo4j/rtree/nearest/MinDist.java

@@ -0,0 +1,52 @@
+package org.wowtools.neo4j.rtree.nearest;
+
+/**
+ * Class that can calculate the MINDIST between a point and a rectangle
+ */
+public class MinDist {
+    /**
+     * Do not instantiate
+     */
+    private MinDist() {
+        // empty
+    }
+
+    /**
+     * 距离的平方
+     * Calculate the MINDIST between the given MBRND and the given point
+     *
+     * @param bbox the bounding box to use
+     * @param x    the point x
+     * @param y    the point y
+     * @return the squared distance
+     */
+    public static double get(double[] bbox, double x, double y) {
+        double res =
+                dd(x, bbox[0], bbox[2]) +
+                        dd(y, bbox[1], bbox[3]);
+        return res;
+    }
+
+    /**
+     * 某个维度上距离的平方
+     *
+     * @param o
+     * @param min
+     * @param max
+     * @return
+     */
+    private static double dd(double o, double min, double max) {
+        double rv = r(o, min, max);
+        double dr = o - rv;
+        return dr * dr;
+    }
+
+    private static double r(double x, double min, double max) {
+        double r = x;
+        if (x < min)
+            r = min;
+        if (x > max)
+            r = max;
+        return r;
+    }
+}

src/main/java/org/wowtools/neo4j/rtree/nearest/MinDistComparator.java

@@ -0,0 +1,31 @@
+package org.wowtools.neo4j.rtree.nearest;
+
+import org.neo4j.graphdb.Node;
+import org.wowtools.neo4j.rtree.Constant;
+
+import java.util.Comparator;
+
+/**
+ * A comparator that uses the MINDIST metrics to sort Nodes
+ *
+ * @author liuyu
+ * @date 2020/6/12
+ */
+public class MinDistComparator implements Comparator<Node> {
+    public final double x;
+    public final double y;
+
+    public MinDistComparator(double x, double y) {
+        this.x = x;
+        this.y = y;
+    }
+
+
+    @Override
+    public int compare(Node n1, Node n2) {
+        double[] bbox1 = (double[]) n1.getProperty(Constant.RtreeProperty.bbox);
+        double[] bbox2 = (double[]) n2.getProperty(Constant.RtreeProperty.bbox);
+        return Double.compare(MinDist.get(bbox1, x, y),
+                MinDist.get(bbox2, x, y));
+    }
+}

src/main/java/org/wowtools/neo4j/rtree/nearest/NearestNeighbour.java

@@ -0,0 +1,141 @@
+package org.wowtools.neo4j.rtree.nearest;
+
+/**
+ * @author liuyu
+ * @date 2020/6/12
+ */
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.Point;
+import org.locationtech.jts.io.ParseException;
+import org.locationtech.jts.io.WKBReader;
+import org.neo4j.graphdb.Direction;
+import org.neo4j.graphdb.Node;
+import org.neo4j.graphdb.Relationship;
+import org.wowtools.neo4j.rtree.Constant;
+import org.wowtools.neo4j.rtree.RtreeNearestQuery;
+
+import java.util.*;
+
+public class NearestNeighbour {
+
+    private final RtreeNearestQuery.NodeFilter filter;
+    private final int maxHits;
+    private final Node root;
+    private final double x;
+    private final double y;
+    private final Point point;
+    private final String getGeometryFieldName;
+    private final WKBReader wkbReader = new WKBReader();
+
+    public NearestNeighbour(RtreeNearestQuery.NodeFilter filter, int maxHits, Node root, double x, double y, String getGeometryFieldName) {
+        this.filter = filter;
+        this.maxHits = maxHits;
+        this.root = root;
+        this.x = x;
+        this.y = y;
+        this.getGeometryFieldName = getGeometryFieldName;
+        point = new GeometryFactory().createPoint(new Coordinate(x, y));
+    }
+
+    /**
+     * @return the nearest neighbour
+     */
+    public List<DistanceResult> find() {
+        List<DistanceResult> ret =
+                new ArrayList<>(maxHits);
+        MinDistComparator nc =
+                new MinDistComparator(x, y);
+        PriorityQueue<Node> queue = new PriorityQueue<Node>(20, nc);
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            Node n = queue.remove();
+            if (n.hasRelationship(Direction.OUTGOING, Constant.Relationship.RTREE_CHILD)) {
+                nnExpandInternal(n, ret, maxHits, queue, nc);
+            } else if (n.hasRelationship(Direction.OUTGOING, Constant.Relationship.RTREE_REFERENCE)) {
+                nnExpandLeaf(n, filter, ret, maxHits);
+            }
+        }
+        return ret;
+    }
+
+
+    /**
+     * 访问索引上的非叶子节点
+     * @param node
+     * @param drs
+     * @param maxHits
+     * @param queue
+     * @param mdc
+     */
+    private void nnExpandInternal(Node node,
+                                  List<DistanceResult> drs,
+                                  int maxHits,
+                                  PriorityQueue<Node> queue,
+                                  MinDistComparator mdc) {
+        double[] bbox = (double[]) node.getProperty(Constant.RtreeProperty.bbox);
+        for (Relationship relationship : node.getRelationships(Direction.OUTGOING, Constant.Relationship.RTREE_CHILD)) {
+            Node n = relationship.getEndNode();
+            double minDist = MinDist.get(bbox, x, y);
+            int t = drs.size();
+            // drs is sorted so we can check only the last entry
+            if (t < maxHits || minDist <= drs.get(t - 1).getDist())
+                queue.add(n);
+        }
+    }
+
+    /**
+     * 访问索引上的叶子节点
+     * @param node
+     * @param filter
+     * @param drs
+     * @param maxHits
+     */
+    private void nnExpandLeaf(
+            Node node,
+            RtreeNearestQuery.NodeFilter filter,
+            List<DistanceResult> drs,
+            int maxHits) {
+        for (Relationship relationship : node.getRelationships(Direction.OUTGOING, Constant.Relationship.RTREE_REFERENCE)) {
+            Node objNode = relationship.getEndNode();
+            Geometry geometry;
+            byte[] wkb = (byte[]) objNode.getProperty(getGeometryFieldName);
+            try {
+                geometry = wkbReader.read(wkb);
+            } catch (ParseException e) {
+                throw new RuntimeException("parse wkb error", e);
+            }
+            if (filter.accept(objNode,geometry)) {
+                double dist = geometry.distance(point);
+                int n = drs.size();
+                if (n < maxHits || dist < drs.get(n - 1).getDist()) {
+                    add(drs, new DistanceResult(objNode, dist, geometry), maxHits);
+                }
+            }
+        }
+    }
+
+    private void add(List<DistanceResult> drs,
+                     DistanceResult dr,
+                     int maxHits) {
+        int n = drs.size();
+        if (n == maxHits)
+            drs.remove(n - 1);
+        int pos = Collections.binarySearch(drs, dr, comp);
+        if (pos < 0) {
+            // binarySearch return -(pos + 1) for new entries
+            pos = -(pos + 1);
+        }
+        drs.add(pos, dr);
+    }
+
+    private static final Comparator<DistanceResult> comp =
+            new Comparator<DistanceResult>() {
+                public int compare(DistanceResult d1, DistanceResult d2) {
+                    return Double.compare(d1.getDist(), d2.getDist());
+                }
+            };
+
+}