Find Overlapping Trajectories - mongodb

Question

Consider the following case :
I have stored trips/trajectories in mongodb as LineString and index is 2dsphere.
According to the image provided, Trip 1 is a trajectory that a user wants to search for and Trip2-6 are trips that are already stored on mongodb.
Given a maxDistance on $near, Trip1 should be "matched" with Trip 3 and 4 as shown.
However $geointersects seem to accept a Polygon or Multipolygon as $geometry type and $near seem to accept only Point.
Is there any time efficient way to implement the following scenario with mongo queries?
Thanks!
EDIT : I changed geometry to Polygon, as Alex Blex said.
Visualisation of data (Trip 1 is the search Trip, Trip2-3 are stored in db)
So we have the following documents stored on mongo:
Trip2
tripData: Object
{
type: Polygon
coordinates: [
[ [8,2] , [7,3] , [7,4], [8,2] ]
]
}
Trip3
tripData: Object
{
type: Polygon
coordinates: [
[ [3,1], [4,1], [4,1.9999], [3,1] ]
]
}
Trip 1 is the trip we search for
tripData: Object
{
type: Polygon
coordinates: [
[ [2,2] , [1,4] , [3,5] , [4,2] , [2,2] ]
]
}
The query i run is the following :
db.trips.find({ tripData: { $geoIntersects : { $geometry : trip1 } } } )
Nothing is returned from this query as expected, because trips do not intersect as you can see in the Visualisation. How can i modify the query in order to match Trip1 with Trip3 using $near operator ?

Answer 1

geoIntersects requires polygons or multipolygons in the query, i.e. Trip1 in the question. Trip2-6 are LineString stored in the documents, which is perfectly fine. So the only extra thing to do is to convert Trip1 to polygon using offset, shown as lime near in the question.
Let's consider straight line first. The function to convert line [[x1,y1][x2,y2]] to polygon with offset d can be as simple as:
function LineToPolyWithFalsePositive(line, d) {
var teta = Math.atan2(line[1][0] - line[0][0], line[1][1] - line[0][1]);
var s = Math.sin(teta);
var c = Math.cos(teta);
return [
[line[0][0] - d*s - d*c, line[0][1] - d*c + d*s],
[line[1][0] + d*s - d*c, line[1][1] + d*c + d*s],
[line[1][0] + d*s + d*c, line[1][1] + d*c - d*s],
[line[0][0] - d*s + d*c, line[0][1] - d*c - d*s]
];
}
or
function LineToPolyWithFalseNegative(line, d) {
var teta = Math.atan2(line[1][0] - line[0][0], line[1][1] - line[0][1]);
var s = Math.sin(teta);
var c = Math.cos(teta);
return [
[line[0][0] - d*s, line[0][1] - d*c],
[line[0][0] - d*c, line[0][1] + d*s],
[line[1][0] - d*c, line[1][1] + d*s],
[line[1][0] + d*s, line[1][1] + d*c],
[line[1][0] + d*c, line[1][1] - d*s],
[line[0][0] + d*c, line[0][1] - d*s]
];
}
Which produce lime polygons as on the image below:
The returned value can be used in geoIntersects query against documents with LineString locations.
The problematic areas highlighted with red. The first poly covers distance more than d on edge cases, and the second poly covers less distance than d in the same edge cases.
If it was the only problem, I would go with false negative approach and run 2 more near queries for Points [x1,y1] and [x2,y2] to check if there are any missed documents in the highlighted areas.
If Trip1 is a complex LineString, there are much more calculations need to be done to convert it to polygon. See the image:
Apart from the edge cases for first and last point, there are similar problems for start and end of each segment. Basically you will need to calculate an angle between each segment to workout corresponded vertices of the polygon. Still doable thou. In the false-negative version of the polygon, the vertices circled with red should be cut, again considering the angle between segments.
If the Trip1 line in the query have many segments, it may be quite expensive, as you will need to run near query for each vertex + 2 for terminal points.
As a pragmatic approach, if it is acceptable, the false-positive version may work quite fast, as it is a single query.