topic Re: Generate Near Table in Geoprocessing Questions

Generate Near Table

SukhRehal — Fri, 20 Feb 2015 16:48:45 GMT

Hi Guys,

hope everyone is well?

I'm hoping someone can help me here, is there a way to generate something like a 'near table' (http://help.arcgis.com/en/arcgisdesktop/10.0/help/index.html#//00080000001n000000) with a basic level user licence?

Are there any work around's you can suggest?

Thanks in advance for any help.

I'm using ArcGIS 10.2

Re: Generate Near Table

XanderBakker — Fri, 20 Feb 2015 16:56:14 GMT

You can probably do something (very) simplified with some Python code, loading the data into a dictionary and analyzing it, but this method should not be executed on larger data sets or multiple data sets. How many featureclasses with how many features and what geometry type do you want to use?

Re: Generate Near Table

SukhRehal — Fri, 20 Feb 2015 17:00:31 GMT

Hi Xander,

I have 1000s of points, in this case just under 5000.

Additionally, I wouldnt have a clue where to begin with python

Re: Generate Near Table

XanderBakker — Fri, 20 Feb 2015 17:06:26 GMT

Are the points in a single featureclass or are they stored in 2 or more featureclasses. I could probably write something, but it depends on what you want to achieve.

What options should be supported:

search_radius
location
angle
closest
closest_count
method

From all the development languages for ArcGIS, Python is probably the easiest to learn...

Re: Generate Near Table

SukhRehal — Sat, 21 Feb 2015 11:03:30 GMT

Hi Xander,

What I did was convert a polygon to a points, what I was hoping to achieve is get the xy of of the closest point on a polygon to the closest point on a polyline (which I also converted to points, so I could get the xy). In the end my aim is to create a line between the 2 XY points, for this I would have used XY to Line tool.

Thanks again,

Re: Generate Near Table

XanderBakker — Sat, 21 Feb 2015 15:14:27 GMT

OK, that sounds a little different, but this can be done using some Python code. What I wonder is how the polygon was translated to point. Did you use the label point or true centroid or is it a point on the perimeter of the polygon?

The line does not have to be converted to points. For each point (from the polygon) to nearest point to a line can be determined. This can yield to point on the line too, which subsequently can be used to create the "near" line.

Re: Generate Near Table

SukhRehal — Sun, 22 Feb 2015 10:37:00 GMT

Hi Xander, apologies for the late reply.

I converted the polygon to lines, which was straight forward and then created points along the line using a toolbox called Create Points On Line (http://ianbroad.com/arcgis-toolbox-create-points-polylines-arcpy/). Thinking about it now it clearly wasn't the right approach.

Re: Generate Near Table

XanderBakker — Mon, 23 Feb 2015 12:01:17 GMT

The idea of converting the polygon and line features to points and perform the analysis with the points is not a strange or bad idea. Just look at this thread: Distance between two linear features? which does the same (yet requires an Advanced/ArcInfo license)

Just to understand a little more of what you are doing, what do the polygons and lines represent? Can you attach a screendump of your data? This to determine the complexity of your geometries.

What I would be thinking of is using Python to loop through points on the boundary of the polygon (no conversion to lines or points needed) and use the Polyline::queryPointAndDistance (in_point, {as_percentage}) method to query the nearest point on the line feature.

From the Help:

Finds the point on the polyline nearest to the in_point and the distance between those points. Also returns information about the side of the line the in_point is on as well as the distance along the line where the nearest point occurs.

If possible you could attach a small sample of the data you have, and I'll write some code which you can use to process your data.

Re: Generate Near Table

SukhRehal — Mon, 23 Feb 2015 12:25:37 GMT

Hi Xander, The Polygons represent homes and the polylines are road bounderies. What Im trying to go is show a line from the road boundary to the home boundary but using the shortest line.

I haven't attached a screen dump of what I want but I have attached my shapefiles. Hope this helps? Let me know i there is anything additional you may need.

Regards

Sukh

Re: Generate Near Table

XanderBakker — Sat, 11 Dec 2021 09:18:49 GMT

The code below will generate the following result:

Change the input and output featureclasses on line 5, 6 and 7. The output featureclass (shapefile) will be created.

On line 10 you can play with the precision (stepsize). In this case I specified 1 (m).

def main():
    import arcpy

    # inputs and output
    fc_pol = r"D:\Xander\GeoNet\NearLines\Polygons.shp"
    fc_lin = r"D:\Xander\GeoNet\NearLines\Road_Boundary.shp"
    fc_out = r"D:\Xander\GeoNet\NearLines\lines02.shp"

    # precision (m)
    stepsize = 1 # extract point on boundary polygon every 1 meter

    sr = arcpy.Describe(fc_lin).spatialReference

    # create list of line geometries
    lst_lines = [r[0] for r in arcpy.da.SearchCursor(fc_lin, ("SHAPE@"))]

    # loop through polygons
    lst_res = []
    with arcpy.da.SearchCursor(fc_pol, ("SHAPE@")) as curs:
        for row in curs:
            polygon = row[0]
            boundary = polygon.boundary()
            dist_min = None

            for i in range(0, int(boundary.length), stepsize):
                point_pol = boundary.positionAlongLine(i, False)

                for line in lst_lines:
                    pntg, val, dist, right_side = line.queryPointAndDistance(point_pol, False)
                    if dist_min is None:
                        dist_min = dist
                        pnt_lin_found = arcpy.Point(pntg.firstPoint.X, pntg.firstPoint.Y)
                        pnt_pol_found = arcpy.Point(point_pol.firstPoint.X, point_pol.firstPoint.Y)
                    else:
                        if dist < dist_min:
                            dist_min = dist
                            pnt_lin_found = arcpy.Point(pntg.firstPoint.X, pntg.firstPoint.Y)
                            pnt_pol_found = arcpy.Point(point_pol.firstPoint.X, point_pol.firstPoint.Y)

            line_out = arcpy.Polyline(arcpy.Array([pnt_lin_found, pnt_pol_found]), sr)
            lst_res.append(line_out)

    arcpy.CopyFeatures_management(lst_res, fc_out)

if __name__ == '__main__':
    main()

Kind regards, Xander

Re: Generate Near Table

XanderBakker — Sat, 11 Dec 2021 09:18:52 GMT

and in case you want to keep a reference to the input data, you can write the input OID of the polygons and lines to the output featureclass like this:

def main():
    import arcpy
    import os

    # inputs and output
    fc_pol = r"D:\Xander\GeoNet\NearLines\Polygons.shp"
    fc_lin = r"D:\Xander\GeoNet\NearLines\Road_Boundary.shp"
    fc_out = r"D:\Xander\GeoNet\NearLines\lines04.shp"

    # output fields
    fld_oid_polygon = "OIDpolygon"
    fld_oid_line = "OIDline"
    flds_add = [fld_oid_polygon, fld_oid_line]

    # precision (m)
    stepsize = 1 # extract point on boundary polygon every 1 meter

    sr = arcpy.Describe(fc_lin).spatialReference

    # create empty output fc
    fc_ws, fc_name = os.path.split(fc_out)
    arcpy.CreateFeatureclass_management(fc_ws, fc_name, "POLYLINE", spatial_reference=sr)

    # add fields
    for fldname in flds_add:
        arcpy.AddField_management(fc_out, fldname, "LONG")

    # create dict of oid vs line geometries
    dct_lines = {r[0]: r[1] for r in arcpy.da.SearchCursor(fc_lin, ("OID@", "SHAPE@"))}

    # insert cursor
    flds = ["SHAPE@"]
    flds.extend(flds_add)
    with arcpy.da.InsertCursor(fc_out, flds) as curs_out:

        # loop through polygons
        lst_res = []
        with arcpy.da.SearchCursor(fc_pol, ("SHAPE@", "OID@")) as curs:
            for row in curs:
                polygon = row[0]
                oid_polygon = row[1]
                boundary = polygon.boundary()
                dist_min = None

                for i in range(0, int(boundary.length), stepsize):
                    point_pol = boundary.positionAlongLine(i, False)

                    for oid_line, line in dct_lines.items():
                        pntg, val, dist, right_side = line.queryPointAndDistance(point_pol, False)
                        if dist_min is None:
                            dist_min = dist
                            pnt_lin_found = arcpy.Point(pntg.firstPoint.X, pntg.firstPoint.Y)
                            pnt_pol_found = arcpy.Point(point_pol.firstPoint.X, point_pol.firstPoint.Y)
                            oid_line_found = oid_line
                        else:
                            if dist < dist_min:
                                dist_min = dist
                                pnt_lin_found = arcpy.Point(pntg.firstPoint.X, pntg.firstPoint.Y)
                                pnt_pol_found = arcpy.Point(point_pol.firstPoint.X, point_pol.firstPoint.Y)
                                oid_line_found = oid_line

                polyline = arcpy.Polyline(arcpy.Array([pnt_lin_found, pnt_pol_found]), sr)
                row_out = (polyline, oid_polygon, oid_line_found, )
                curs_out.insertRow(row_out)

if __name__ == '__main__':
    main()

Re: Generate Near Table

SukhRehal — Mon, 23 Feb 2015 15:31:53 GMT

Thank you Xander,

your screen shot is exactly what I wanted.

Do I simply paste this into the code window? I will try to create a toolbox.

Re: Generate Near Table

XanderBakker — Sat, 11 Dec 2021 09:18:55 GMT

I normally run the code from a stand alone IDE (I use PyScripter), but you can run the code from the python window (it will not add the result to the TOC, though). Before you run it, make sure you change the paths to your input data and provide a valid output name/path.

You can also create a toolbox from it. Use the arcpy.GetParameterAsText() to collect the inputs

    fc_pol = arcpy.GetParameterAsText(0) # featurelayer, filter on polygon, direction is input
    fc_lin = arcpy.GetParameterAsText(1) # featurelayer, filter on polyline, direction is input
    fc_out = arcpy.GetParameterAsText(2) # featureclass, direction is output

If you have problems, post them back and I can have a look at it.

If it works, please mark the thread as answered (at the post that answered your question). If a post was helpful you can mark the post as such using the links below the post Helpful Yes | No

Re: Generate Near Table

StanaforthHopkins — Tue, 21 Apr 2015 18:19:03 GMT

You offer hope for the hobbyist. If python routines can substitute for geoprocesswing nd perhaps more, a $10K professional licene my not be needed.