GeometryEngine.Distance much slower since Pro 3.3
I spent some time and built out a number of identical VMs each with a different version of ArcGIS Pro installed. I took the Naperville sample data and pulled out 5,000 points from that data (see attached) and ran some geometry methods between the points and noted the total time to complete. The results can be seen here along with a comparison of the difference between Pro 3.1 and the other versions...
Here's the code that does the calculations...
await QueuedTask.Run(() =>
{
var Layer = MapView.Active.Map.GetLayersAsFlattenedList().First();
var FeatLayer = Layer as BasicFeatureLayer;
var Feat = null as Feature;
var Point = null as MapPoint;
var TestFeats = new List<Feature>();
var TestPoints = new List<MapPoint>();
var Time1 = DateTime.Now.Ticks;
using (var Cursor = FeatLayer.Search())
{
// First feature is our test point
Cursor.MoveNext();
Feat = Cursor.Current as Feature;
Point = Feat.GetShape() as MapPoint;
while (Cursor.MoveNext())
{
var TestFeat = Cursor.Current as Feature;
TestFeats.Add(TestFeat);
TestPoints.Add(TestFeat.GetShape() as MapPoint);
}
}
var Time2 = DateTime.Now.Ticks;
foreach (var TestPoint in TestPoints)
{
var Dist = GeometryEngine.Instance.Distance(TestPoint, Point);
}
var Time3 = DateTime.Now.Ticks;
foreach (var TestPoint in TestPoints)
{
var NearPoint = GeometryEngine.Instance.NearestPoint(TestPoint, Point);
}
var Time4 = DateTime.Now.Ticks;
foreach (var TestPoint in TestPoints)
{
var Buffer = GeometryEngine.Instance.Buffer(TestPoint, 5);
var Int = GeometryEngine.Instance.Intersects(Buffer, Point);
}
var Time5 = DateTime.Now.Ticks;
var CursorTime = new TimeSpan(Time2 - Time1);
var DistanceTime = new TimeSpan(Time3 - Time2);
var NearestTime = new TimeSpan(Time4 - Time3);
var BufferTime = new TimeSpan(Time5 - Time4);
var Result = $"Points: {TestPoints.Count:#,0}\n" +
$"Cursor: {CursorTime.TotalMilliseconds:0.00}ms\n" +
$"Distance: {DistanceTime.TotalMilliseconds:0.00}ms\n" +
$"Nearest: {NearestTime.TotalMilliseconds:0.00}ms\n" +
$"Buffer: {BufferTime.TotalMilliseconds:0.00}ms\n";
System.Diagnostics.Debug.WriteLine(Result);
MessageBox.Show(Result);
});
The first thing I noticed that this test takes a little over 1 second for the Distance method compared to my previous tests that was taking about 100ms which is 10x slower. Not sure what is different between that data and the code I was using that accounts for this difference. Everything seems to be the same. So it makes the difference between versions less extreme. But the differences are still there. Pro 3.1 and 3.2 are essentially the same. Pro 3.3 and 3.4 are about 3x slower for the three geometry methods I tested, Distance, NearestPoint and Buffer. I also included a Intersects check with the Buffer as the goal of using these methods are to determine features within distances. The buffer needs that additional check so I included it. Pro 3.5 and 3.6 have similar issues with Distance and NearestPoint but something seems to have changed with the Buffer and it's about 10x faster than Pro 3.1. So that's good to see.
Back in the day with ArcObjects, I tended to use Buffer a lot. But the buffer method was updated at some point and became a bottleneck so I stopped using it unless I really needed it. Often using Distance instead as that was much faster. Fast forward to Pro 3.5+, Buffer seems to be the way to go when it's appropriate for the calculation. I still need to know actual distances in many cases so I can't use buffer for that. But interestingly, NearestPoint seems consistently 2x faster than Distance which seems odd. NearestPoint does also return the distance to that nearest point so in that sense it's doing the same thing. But I would assume NearestPoint would be doing more things potentially as for linear geometries it calculates segment and part index as well. But I guess for a point to point, the nearest point is just the only point in the geometry (except multi-points) and it really is just calculating the distance. This all suggests that Distance is doing something that takes more time that NearPoint isn't doing in its distance calculation. Without knowing what that is and if it will affect my processes, I would guess NearestPoint would be the more efficient way to get the distance instead of Distance. But of course NearestPoint still took the same performance hit that Distance did at Pro 3.3+.
With Buffer being pretty similar to NearestPoint in the worse cases, using Buffer to filter for general nearby queries and NearestPoint to get actual distances is the way to go. It's still going to be bad in Pro 3.3 and 3.4 but the increase in Buffer performance in Pro 3.5+ should help balance it a little. Of course if the performance of Distance and NearestPoint could improve back to where they were in Pro 3.2, that would be even better. If there's any specific details about what is different between these methods and what changes were made between the Pro versions, that would be helpful to know so I can write my tools around those known parameters.
