CODEWITHSUNDEEP
javascalalambdapredicatescala-java-interop
Georg Heiler
Georg Heiler

Reputation: 17694

port java lambda predicate to scala

How can I port https://github.com/davidmoten/rtree2/blob/master/src/test/java/com/github/davidmoten/rtree2/LatLongExampleTest.java#L55

Iterables.filter(tree
                // do the first search using the bounds
                .search(bounds),
                // refine using the exact distance
                entry -> {
                    Point p = entry.geometry();
                    Position position = Position.create(p.y(), p.x());
                    return from.getDistanceToKm(position) < distanceKm;
                });

from Java to scala? My approach below fails:

import com.github.davidmoten.grumpy.core.Position
import com.github.davidmoten.rtree2.{Iterables, RTree}
import com.github.davidmoten.rtree2.geometry.{Geometries, Point}

val sydney = Geometries.point(151.2094, -33.86)
val canberra = Geometries.point(149.1244, -35.3075)
val brisbane = Geometries.point(153.0278, -27.4679)
val bungendore = Geometries.point(149.4500, -35.2500)

var tree = RTree.star.create[String, Point]
tree = tree.add("Sydney", sydney)
tree = tree.add("Brisbane", brisbane)

val distanceKm = 300
val list = Iterables.toList(search(tree, canberra, distanceKm))

def createBounds(from: Position, distanceKm: Double) = { // this calculates a pretty accurate bounding box. Depending on the
  // performance you require you wouldn't have to be this accurate because
  // accuracy is enforced later
  val north = from.predict(distanceKm, 0)
  val south = from.predict(distanceKm, 180)
  val east = from.predict(distanceKm, 90)
  val west = from.predict(distanceKm, 270)
  Geometries.rectangle(west.getLon, south.getLat, east.getLon, north.getLat)
}

import com.github.davidmoten.grumpy.core.Position
import com.github.davidmoten.rtree2.RTree

def search[T](tree: RTree[String, Point], lonLat: Point, distanceKm: Double) = { // First we need to calculate an enclosing lat long rectangle for this
  // distance then we refine on the exact distance
  val from = Position.create(lonLat.y, lonLat.x)
  val bounds = createBounds(from, distanceKm)
  Iterables.filter(tree.search // do the first search using the bounds
  (bounds), // refine using the exact distance
    (entry) => {
      def foo(entry) = {
        val p = entry.geometry
        val position = Position.create(p.y, p.x)
        from.getDistanceToKm(position) < distanceKm
      }

      foo(entry)
    })
}

as the type of entry does not seem to be well defined.

Upvotes: 0

Views: 316

Answers (1)

Dmytro Mitin
Dmytro Mitin

Reputation: 51683

tree has type RTree[String, Point] so T=String, S=Point. So tree.search(bounds) has type Iterable[Entry[String, Point]]. So entry has type Entry[String, Point].

Try

(entry: Entry[String,Point]) => {
  def foo(entry: Entry[String,Point]) = {
    val p = entry.geometry
    val position = Position.create(p.y, p.x)
    from.getDistanceToKm(position) < distanceKm
  }

  foo(entry)
})

Tested in Scala 2.13.0, rtree2 0.9-RC1, grumpy-core 0.2.4.

In 2.11 this should be just

import scala.compat.java8.FunctionConverters._

((entry: Entry[String,Point]) => {
  def foo(entry: Entry[String,Point]) = {
    val p = entry.geometry
    val position = Position.create(p.y, p.x)
    from.getDistanceToKm(position) < distanceKm
  }

  foo(entry)
}).asJava

libraryDependencies += "org.scala-lang.modules" %% "scala-java8-compat" % "0.9.0"

Upvotes: 2

Related Questions