Dot Net Methods to do Spatial Join operations

[KTT_Mercury]

Hello - I would need some help pointing me to the library methods or the like to achieve the equivalent operation of Esri Spatial Joint geoprocessing tool in ArcGIS Pro 3.5

I have a feature of center-lines network (like streets and highways) then I have a feature layer of points. I was given the radius tolerance of a certain feet to do a spatial-joint of the 2-D features to allocate all the street IDs that the radius crosses from that point. I think of intersection operation equivalency, but even so, this discussion/documentation I've found seem to be brief: Geometry | ArcGIS Maps SDK for .NET | Esri Developer - my guess is I would pick pint and polylines, but I am working with Feature Layers, and mostly likely import the physical Feature Layer directly from #C code (instead of getting it from Feature Service link)

Can someone help me with more resource to read or example project to do, like intersection of 2 layers hand-on project utilizing .NET Maps SDK? I would need to get/import a Feature Layer into my .NET WPF Project first, is there such method and classes available if I am not given a Feature Service URL to invoke? 

Any help is greatly appreciated.

[imalcolm_esri]

Hello,

It would be helpful if you could explain the full workflow you need the spatial join for. You can manually implement a spatial join using the native maps sdks, but it could be quite slow depending on how many points and lines you are dealing with. If you do have many lines and points, and if the computation must be done for your full datasets all at once, it might be worthwhile to precompute the results in ArcGIS Pro. Implementing a join in the native sdks would make the most sense if you only need to do the spatial join using a few points at a time, or if your datasets are not large.

In the meantime here are some links that should be useful:

• GeometryEngine: https://developers.arcgis.com/net/api-reference/api/net/Esri.ArcGISRuntime/Esri.ArcGISRuntime.Geomet...
  • This is the relevant class for geometry calculations. Check out the Buffer() and BufferGeodetic() functions in particular
• FeatureTable.QueryFeaturesAsync(): https://developers.arcgis.com/net/api-reference/api/net/Esri.ArcGISRuntime/Esri.ArcGISRuntime.Data.F...
  • This function has support for querying features based on geometry relationships
• Offline data files documentation: https://developers.arcgis.com/net/offline-maps-scenes-and-data/work-with-data-files/
  • We do not support opening file geodatabases directly, but you can create a mobile geodatase, geopackage, or shapefile from your data using Pro

Here is some example code for what a spatial join could look like. This appends data from a point to surrounding lines, though after re-reading what you said I imagine you want the opposite (line data to points). The basic concept should still hold, though.

Other notes on the code:

• A full join would loop through all the points, not just take the first
• Using BufferGeodetic() was probably overkill, and Buffer() would be more performant if there are many points
• I switched to a FeatureCollectionTable for the final joined table, but there are several options, including writing back to the original mobile geodatabase file
• This does not include any logic for when a line might be in range of multiple points, but that may not be an issue depending on the use case

var databasePath = @"";
var pointTableName = "";
var lineTableName = "';

// Open geodatabase
var mobileGeodatabase = await Geodatabase.OpenAsync(databasePath);

// Make point buffer
var pointFeatureTable = mobileGeodatabase.GetGeodatabaseFeatureTable(pointTableName)!;
var pointQueryResult = await pointFeatureTable.QueryFeaturesAsync(new QueryParameters() { WhereClause = "1=1" });
var pointFeature = pointQueryResult.First(); // With multiple points you would want to loop through all the points, not just take the first one
var pointBuffer = GeometryEngine.BufferGeodetic(pointFeature.Geometry!, 1000, LinearUnits.Feet);

// Query lines that intersect the buffer
var lineFeatureTable = mobileGeodatabase.GetGeodatabaseFeatureTable(lineTableName)!;
var linesAroundPoint = await lineFeatureTable.QueryFeaturesAsync(new QueryParameters() { Geometry = pointBuffer, SpatialRelationship = SpatialRelationship.Intersects });

// Create line layer and select intersecting lines
var lineLayer = new FeatureLayer(lineFeatureTable);
lineLayer.SelectFeatures(linesAroundPoint);

// Join attributes
var joinedFields = lineFeatureTable.Fields.ToList();
joinedFields.Add(pointFeatureTable.Fields.Where((f) => f.Name != "OBJECTID").First());
var joinedCollectionTable = new FeatureCollectionTable(joinedFields, GeometryType.Polyline, lineFeatureTable.SpatialReference);
var joinedLineFeatures = new List<Feature>(linesAroundPoint.Count());
foreach (var lineFeature in linesAroundPoint)
{
    var joinedLineFeature = joinedCollectionTable.CreateFeature();
    joinedLineFeature.Geometry = lineFeature.Geometry;
    foreach (var attribute in lineFeature.Attributes)
    {
        // You may want to do something special with the OBJECT id field rather than just ignore it
        if (attribute.Key != "OBJECTID" && joinedLineFeature.Attributes.ContainsKey(attribute.Key))
            joinedLineFeature.Attributes[attribute.Key] = attribute.Value;
    }
    foreach (var attribute in pointFeature.Attributes)
    {
        if (attribute.Key != "OBJECTID" && joinedLineFeature.Attributes.ContainsKey(attribute.Key))
            joinedLineFeature.Attributes[attribute.Key] = attribute.Value;
    }
    joinedLineFeatures.Add(joinedLineFeature);
}
await joinedCollectionTable.AddFeaturesAsync(joinedLineFeatures);

// Get the features out of the collection table to verify its contents
var joinedFeaturesQueryResult = await joinedCollectionTable.QueryFeaturesAsync(new QueryParameters() { WhereClause = "1=1" });

[KTT_Mercury]

I've found this tutorial https://developers.arcgis.com/net/wpf/sample-code/perform-spatial-operations/

From my end, the collection of points is coming from the result of using "XY Table to Point" geoprocessing tool in Arcgis Pro given a set of longitudes and latitudes table fed in tool. So now I have a point feature class in Arcgis Pro environment. Anyhow, first thing first, (1) where do I go about getting the operation of "XY Table to Point" programmed in C#? Almost each geoprocessing tool has its equivalent operation described in Python, but not readily in C#, so is .NET Map SDK the resource I can count on to do the equivalent things so that the result may be recognized as  Feature Layer by the NET Map SDK platform, which may be equivalent to Feature class of Argis, pro, I am hopign they will have the same columns/objects as a result?

The same thing with Spatial Join geoprocessing tool, it needs a Target Feature Class and a Join Feature Class passed into form, and one can get the Python code equivalent of this operation, however in .NET (2.a) how doI go about to import an Arcgis Pro Feature Class  programmatically so that the C# WPM program would convert it to Feature Layer? (2.b) What are the equivalent C# methods to perform Spatial Join?

(3) Am I limited to Feature Layer data type? This is the type I had worked with before through a published Feature Service link given to me, there a C# method to invoke the link and I do query against the result (which is a  Feature Layer)

But now I move on to do 2 more operations: one is  "XY Table to Point" described above, followed by a "Spatial Join" operation.  I'm not sure how to start with the point being defined as longitude and latitude (the attribute table behind the resulted Feature Class after doing XY Table to Point geoprocessing tool in Argis Pro does reserve 2 columns longitude and latitude but no other data, do you think I can redefined the geometry point using these same long/lats? rather than what illustrated in the example link above? geometry or feature layer?

Any feed back in appreciated.

[imalcolm_esri]

To answer your questions:

1. There are two different .NET SDKs in the ArcGIS ecosystem. This forum covers the ArcGIS Maps SDK for .NET, which it does sound like you are using given your WPF app. The other SDK is the ArcGIS Pro SDK for .NET. The Pro SDK is similar to arcpy in that it can be used for scripting using existing geoprocessing tools from Pro, though unlike arcpy it can also be used to modify Pro itself (more information here). The use cases are different, and as a result the ArcGIS Maps SDK for .NET does not implement all of the geoprocessing tools provided by Pro. If all you want to do make scripts for geoprocessing workflows, arcpy is probably your best bet. Otherwise if you need to do geoprocessing in your WPF app directly, you will have to implement some functionality manually.
2. Based on the answer to 1:
   
   1. To read a csv file (or similar) for use in the Maps SDK for .NET you will need to parse the file yourself and read its data into one of the subclasses of FeatureTable. This sample has code demonstrating how to create FeatureCollectionTables using known lat/long values (which you would read from the csv).
   2. There is no direct equivalent to spatial join in the Maps SDK for .NET
3. There are several different formats for feature data in the Maps SDK for .NET. As in 2a, see the subclasses of FeatureTable.
4. The sample linked in 2a should help with using the lat/long points to make geometry objects and populate layers.

[KTT_Mercury]

Hello! I think I hit the reply button on my second post just about the same time I saw the notification, and wondering perhaps my original post got reply. And it did! but I had to attend an other urgent matter, so I logged off.

Thank you for the pointers. I will get back to your 2b shortly .