nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

Alternative libraries to arcpy to make the "find conntected" function?

TeresaBartolomei

Hi,

I use ArcGIS Desktop and I would like to build with python the function behind the standard GIS tool "find connected", which is able to select all the feature topologically connected to each other, starting from a given line feature.

I do not need the arcpy.TraceGeometricNetwork function because even though it really gives you all the feature connected to each other, in doing so, it creates other layers, different from the original and I am looking for a solution that selects features inside their original layers.

Does anyone know any other python library that could have this type of funtion related no networks?

Thanks in advance

Find more posts tagged with

Accepted answers

Hornbydd

@HaydenWelch reviewing your code, if I have understood correctly it returns the ObjectID's of the features that intersect the input Polyline? I think @TeresaBartolomei is looking for a solution that would select all connected edges in a graph, as she specifically mentioned networks, so not just the immediate adjacent lines.

If you wanted to program this you are basically looking at using the networkx module.

I have also used this useful tool for coding up connected edges by an ID. This does not require network analyst as it is using networkx.

All comments

Hornbydd

Yeah I think she did that to ensure that the input was indeed a connected network and not some load of unconnected nonsense! That tool could avoid that extension and build the graph as you have suggested. Anyway glad I had not somehow misunderstood your code sample. 😃

Hayden Welch

You are correct, it's a simple starting point for collecting connected identifiers that can then be interpolated into a SELECT clause for feature selection. I didn't implement a network model here because that's a bit out of scope, but if all you need is simple connections, using a function like this is a start for building the graph with OID@ as the nodes.

If you already have the topographical connections encoded in fields like `To_Feature`/`From_Feature` networxx would work well. Otherwise you'll still need something like what I have to build the relations.

Iterating through the immediately adjacent lines and then inserting them into a networxx graph is a good solution, you can also just roll your own graph using Python dictionaries, or a custom Graph class. The main functionality that's needed would be just building those relationships on the fly using simple Cursors and Geometry functions.

I did also notice that the toolbox you shared does include a nax import:

...
arcpy.env.overwriteOutput = True
arcpy.CheckOutExtension("network")

NDpath = arcpy.GetParameter(0)

# Create network dataset object
ND = arcpy.nax.NetworkDataset(NDpath)
...

Hornbydd

If you wanted to program this you are basically looking at using the networkx module.

I have also used this useful tool for coding up connected edges by an ID. This does not require network analyst as it is using networkx.

Hayden Welch

You can implement it yourself using Cursors:

from pathlib import Path
from arcpy import (
    Parameter,
    Polyline,
    Geometry,
)
from arcpy.da import (
    SearchCursor,
)
from arcpy._mp import (
    Layer
)

def find_connected(line: Polyline, feature_classes: list[str|Layer]) -> dict[str, list[int]]:
    """Find all features in each feature class that are connected to the input line
    
    Args:
        line (Polyline): The connecting line that will be used to filter the input features
        feature_classes (list[str|Layer]): A list of paths or Layers that will be searched for connected features
    
    Returns:
        ( dict[str, list[int]] ): A mapping of feature names to connected feature OIDs
    """
    connected = {}
    for fc in feature_classes:
        if isinstance(fc, Layer):
            name = fc.name
        else:
            name = Path(fc).name
            
        connected[name] = [row[0] for row in SearchCursor(fc, ['OID@'], spatial_filter=line, spatial_relationship='INTERSECTS')]
    return connected

Here's a more modular version if you don't need all the OIDs immediately (say you're just gonna loop over them later):

def find_connected(line: Polyline, feature_class: str|Layer) -> Generator[int, None, None]:
    """Find all features in each feature class that are connected to the input line
    
    Args:
        line (Polyline): The connecting line that will be used to filter the input features
        feature_class (str|Layer): The feature class to find connections in
    
    Yields:
        ( int ): Consume this generator 
    """
    yield from (
        row[0] 
        for row in SearchCursor(
            feature_class, 
            ['OID@'], 
            spatial_filter=line, 
            spatial_relationship='INTERSECTS'
            )
        )

def get_connected_for(line: Polyline, feature_classes: list[str|Layer], as_list: bool=True) -> dict[str, list[int]]:
    """Get a mapping of connected features for multiple feature classes
    
    Args:
        line (Polyline) : The connecting line
        feature_classes (list[str|Layer]) : The feature classes to find connections with
        as_list (bool): Flag for returning a sequence of generators or populated lists
    Returns:
        (dict[str, list[int]]) : A mapping of the input fcs to the OIDs of the connected features
    """
    return {
        fc if isinstance(fc, str) else fc.longName: list(find_connected(line, fc)) if as_list else find_connected(line, fc)
        for fc in feature_classes
    }

The first function makes a generator for the supplied connector and feature class, the second will map a sequence of feature classes to either a list of the connected OIDs or to a generator object that can be iterated over one at a time. If you have a ton of connections per line, the generator solution will be a lot more memory efficient, but if you know the upper bound for the number of connections is small (<10 or so) immediately converting that connection generator to a list will be more memory efficient

Here's a quick sample of the size (in bytes) of both calls with ~2-3 connections each:

>>> cxns = get_connected_for(line, ['fc1', 'fc2'], as_list=False)
>>> cxns
{'fc1': <generator object find_connected at 0x000002504CC24400>, 'fc2': <generator object find_connected at 0x000002507BBEBA60>}
>>> getsize(cxns)
1292

...

>>> cxns = get_connected_for(line, ['fc1', 'fc2'])
>>> cxns
{'fc1': [1, 2], 'fc2': [1, 2, 3]}
>>> getsize(cxns)
564

Note: The first example is larger because the generators are a fixed size. That means even if there are a million connections in there, it'll still only be 1292 bytes.

Join the Conversation

Signed in members can post, follow updates, and more. New here? Register a free account.

Quick Links

Community Help
Find useful guides, FAQs, and documents to help you navigate and make the most of Esri Community.