topic Oriented buffers in Geoprocessing Questions

Oriented buffers

davesacco — Sun, 08 Feb 2015 03:58:42 GMT

Hi there,

I am using arcview 9.3.1 and I need to create oriented buffers from points in a shapefile. The euclidean direction method almost works, but because it calculates to the nearest point, buffers associated with points within the maximum will be truncated. I need each point to have a complete buffer in a specific direction, regardless of overlap with other points.

Any ideas would be greatly appreciated.

Thanks,

Dave

Re: Oriented buffers

XanderBakker — Sun, 08 Feb 2015 20:00:53 GMT

Would the table to ellipse tool be of any help?

ArcGIS Help (10.2, 10.2.1, and 10.2.2)

If not a picture to show what you are after would help.

Re: Oriented buffers

davesacco — Sun, 08 Feb 2015 22:54:07 GMT

Hi Xander,

Thanks for taking the time to help out. I'll try this tool out, but I need a different shape so it may not be the solution. I'll attach an image from the euclidean direction tool that will hopefully make this a bit clearer. Without getting into too much detail, I need to illustrate an area that may be a source for the point data. In the attached image, the transport direction ranges from 45-90 degrees, hence the cone shape (the transport vectors vary throughout the data set). My only issue is the truncation in the raster due to the close points. I.e, they need to overlap.

Another idea is to somehow generate 2 lines at specified azimuths from the points and then use them to intersect with a buffer around the point. This would allow for the overlap that the raster does not accommodate.

Pretty stumped right now, so I really appreciate your input and time.

Dave

Re: Oriented buffers

DarrenWiens2 — Sat, 11 Dec 2021 13:52:54 GMT

Here's how you can do this using arcpy and geometry objects:

>>> radius = 200000 # buffer radius
>>> polys = []
>>> sr = arcpy.Describe("YOUR_POINT_LAYER_NAME_HERE").spatialReference
>>> with arcpy.da.SearchCursor("YOUR_POINT_LAYER_NAME_HERE","SHAPE@",'#',sr) as cursor:
...     for row in cursor:
...         pt1 = row[0].centroid
...         pt2 = arcpy.Point(row[0].centroid.X - radius*2, row[0].centroid.Y)
...         pt3 = arcpy.Point(row[0].centroid.X - radius*2, row[0].centroid.Y - radius*2)
...         triangle = arcpy.Polygon(arcpy.Array([pt1,pt2,pt3]),sr)
...         buffer = row[0].buffer(radius)
...         wedge = triangle.intersect(buffer,4)
...         polys.append(wedge)
...         
>>> arcpy.CopyFeatures_management(polys,'in_memory\wedges')
<Result 'in_memory\\wedges'>

It helps that all wedges are the same shape, so the triangle shape used to clip (intersect) the buffer is hard-coded. You could fairly easily alter the script to respond to attribute data.

Sorry for swooping in on your fun, Xander

Re: Oriented buffers

XanderBakker — Mon, 09 Feb 2015 00:38:36 GMT

LOL, it's actually a very nice a simple way of getting the result... So no harm done, thanks for contributing this solution, Darren Wiens‌ and yes I think this would answer the question.

I will however start with a more generic solution that allows for setting the start angle, end angle and distance for each sector and will share it later on.

Re: Oriented buffers

XanderBakker — Sat, 11 Dec 2021 13:52:57 GMT

As promised...

The code below will create the circle sectors based on the point location and 3 additional columns:

one for the start angle
one for the end angle
and the distance (size)

The angles are expressed arithmetically:

In your case you will want to use start = 180° and end = 225°

I used random points, with random angles and random sizes and this was the result:

This is the code I used:

#-------------------------------------------------------------------------------
# Name:        createSectors.py
# Purpose:    create circle sectors for points
#
# Author:      Xander
#
# Created:    08-02-2015
#-------------------------------------------------------------------------------
import arcpy

def main():
    fc_in = r"C:\Forum\CircleSectors\data.gdb\points2"
    fc_out = r"C:\Forum\CircleSectors\data.gdb\sectors2"

    fld_start = "StartAngle"
    fld_end = "EndAngle"
    fld_dist = "Length"

    sr = arcpy.Describe(fc_in).spatialReference
    arcpy.env.overwriteOutput = True

    flds = ("SHAPE@", fld_start, fld_end, fld_dist)
    lst_polygons = []
    with arcpy.da.SearchCursor(fc_in, flds) as curs:
        for row in curs:
            pnt_g = row[0]
            start = row[1]
            end = row[2]
            length = row[3]
            circle = pnt_g.buffer(length)
            pnt = pnt_g.firstPoint
            arrPnts = arcpy.Array()
            arrPnts.add(pnt)
            for bearing in range(int(start), int(end) + 1):
                arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
            polygon = arcpy.Polygon(arrPnts, sr)
            lst_polygons.append(polygon)

    arcpy.CopyFeatures_management(lst_polygons, fc_out)

def createPointAtAngleWithBearing(pnt, angle, distance):
    import math
    angle = math.radians(angle)
    dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
    return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)

if __name__ == '__main__':
    main()

Kind regards, Xander

Re: Oriented buffers

davesacco — Mon, 09 Feb 2015 02:23:59 GMT

Thank you both. You guys are awesome. Seriously. Xander, will Darren see this? not sure how to tag him.

I think the variable sizes and angles will work perfectly. But.. and this is a big one... I am using Arcview 9.3.1, so as far as I can tell, I can't use arcpy. I will try to get access to a machine with a higher version.

I'm not familiar with the commands for arcpy, although it appears it's time to learn. With the inputs referenced from the shapefile, you've bang on solved my problem. Don't even want to think about how many hours I could have saved with other problems.

So.. I'm not sure if this should be under a new thread, but the next step is to determine the percentage of another layer within each of these polygons. Or, more accurately, the types and proportion of each bedrock unit within each polygon. I've just started researching this, but I thought I should ask you guys before I spend too many hours..

I wish I could thank you guys more for the help. It's much appreciated.

Re: Oriented buffers

davesacco — Mon, 09 Feb 2015 07:09:18 GMT

Another quick question. Is it possible to have the point ID field recorded as an attribute in the resulting polygon?

Thanks again!

Re: Oriented buffers

XanderBakker — Mon, 09 Feb 2015 11:48:16 GMT

You are right, it will not work on 9.3.1. And since I am making use of the data access module, You will need to have access to ArcGIS 10.1 SP1 or higher. It would be good to upgrade, since each new version of ArcGIS provides some new goodies. The current version is 10.3.

I don't have access to 9.3.x, so it would be difficult to rewrite it for this version. I could rewrite it for 10.0 and 10.1, but if you are going to upgrade, it's best to pick a higher version. The alternative is to upload your featureclass and I can run it for you and attach the result to this thread.

To learn arcpy (and python) there are a lot of threads where this has been answered and useful links to resources have been provided, like this one: Seeking advice on how to go about learning Python

For getting info on the bedrock units per polygon, you could use a union and analyze the attributes. If you have any problems with that, you can start a new thread (this will attract the attention of more people and will result in more response).

Kind regards, Xander

Re: Oriented buffers

XanderBakker — Mon, 09 Feb 2015 12:56:18 GMT

Yes, it is, but will require some rewriting of the code. I will get back on this in a moment...

Re: Oriented buffers

XanderBakker — Sat, 11 Dec 2021 13:53:00 GMT

I haven't tested this, but it should do the trick (I hope...):

#-------------------------------------------------------------------------------
# Name:       createSectors2.py
# Purpose:    create circle sectors for points
#
# Author:      Xander
#
# Created:    08-02-2015
#-------------------------------------------------------------------------------
import arcpy

def main():
    import os
    fc_in = r"C:\Forum\CircleSectors\data.gdb\points2"
    fc_out = r"C:\Forum\CircleSectors\data.gdb\sectors2"

    fld_start = "StartAngle"
    fld_end = "EndAngle"
    fld_dist = "Length"
    fld_oid = "OIDpoints" # output field with oid of points

    sr = arcpy.Describe(fc_in).spatialReference
    arcpy.env.overwriteOutput = True

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

    # add field to polygon fc to store oid of points
    arcpy.AddField_management(fc_out, fld_oid, "LONG")

    # start insert cursor on polygon fc
    flds_out = ("SHAPE@", fld_oid)
    with arcpy.da.InsertCursor(fc_out, flds_out) as curs_out:

        flds = ("SHAPE@", fld_start, fld_end, fld_dist, "OID@")
        lst_polygons = []
        with arcpy.da.SearchCursor(fc_in, flds) as curs:
            for row in curs:
                pnt_g = row[0]
                start = row[1]
                end = row[2]
                length = row[3]
                oid = row[4]
                circle = pnt_g.buffer(length)
                pnt = pnt_g.firstPoint
                arrPnts = arcpy.Array()
                arrPnts.add(pnt)
                for bearing in range(int(start), int(end) + 1):
                    arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
                polygon = arcpy.Polygon(arrPnts, sr)
                curs_out.insertRow((polygon, oid, ))

def createPointAtAngleWithBearing(pnt, angle, distance):
    import math
    angle = math.radians(angle)
    dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
    return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)

if __name__ == '__main__':
    main()

Re: Oriented buffers

davesacco — Mon, 09 Feb 2015 20:43:12 GMT

I wish I could upgrade, but it's not in the budget. And, thanks for the offer to process the data. I'll decline as I still need to determine the angles to be used for each point and incorporate a surface roughness factor to scale the length. Once I have all the pieces together I should be able to find a machine that I can use for a bit.

As for the data extraction, I converted the bedrock data to a raster and then used the tabulate area tool to create a table that I can join back to the polygons.

Thanks again for your help Xander. I will follow your link on learning python and one day return the favour back to the community!

Re: Oriented buffers

Hayley_DelMaynard — Sat, 18 Feb 2017 09:33:23 GMT

Xander Bakker‌ Thanks so much for this! I'm trying to create 4 90degree buffers around all points in my data frame. I tried using your code and I keep getting this below error. I'm pretty new to Python, do you know how to fix this? Thanks again!

>>> import arcpy
...
... def main():
... fc_in = "C:\Users\A0701216\Documents\ArcGIS\Default.gdb\ALEX"
... fc_out = "C:\Users\A0701216\Documents\ArcGIS\Default.gdb\ALEX_"
...
... fld_start = 180
... fld_end = 225
... fld_dist = 15
...
... sr = arcpy.Describe(fc_in).spatialReference
... arcpy.env.overwriteOutput = True
...
... flds = ("SHAPE@", fld_start, fld_end, fld_dist)
... lst_polygons = [1]
... with arcpy.da.SearchCursor(fc_in, flds) as curs:
... for row in curs:
... pnt_g = row[0]
... start = row[1]
... end = row[2]
... length = row[3]
... circle = pnt_g.buffer(length)
... pnt = pnt_g.firstPoint
... arrPnts = arcpy.Array()
... arrPnts.add(pnt)
... for bearing in range(int(start), int(end) + 1):
... arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
... polygon = arcpy.Polygon(arrPnts, sr)
... lst_polygons.append(polygon)
...
... arcpy.CopyFeatures_management(lst_polygons, fc_out)
...
... def createPointAtAngleWithBearing(pnt, angle, distance):
... import math
... angle = math.radians(angle)
... dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
... return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)
...
... if __name__ == '__main__':
... main()
...
Runtime error
Traceback (most recent call last):
File "<string>", line 40, in <module>
File "<string>", line 16, in main
TypeError: 'field_names' must be string or non empty sequence of strings
>>>

Re: Oriented buffers

DanPatterson_Retired — Sat, 18 Feb 2017 09:38:46 GMT

flds = ("SHAPE@", fld_start, fld_end, fld_dist)

for the last 3, you provided numbers rather than the field names that contained the values

Re: Oriented buffers

Hayley_DelMaynard — Mon, 20 Feb 2017 22:32:23 GMT

Thanks Dan. I really appreciate the quick response. I changed the lines to include the field names, but I still receive the below error message:

Runtime error
Traceback (most recent call last):
File "<string>", line 40, in <module>
File "<string>", line 11, in main
AttributeError: DescribeData: Method spatialReference does not exist

>>> import arcpy
...
... def main():
... fc_in = "C:\Users\ihwm\Documents\ArcGIS\Flood_NT_WA.gdb\points"
... fc_out = "C:\Users\ihwm\Documents\ArcGIS\Flood_NT_WA.gdb\points2"
...
... fld_start = "fld_start"
... fld_end = "fld_end"
... fld_dist = "fld_dist"
...
... sr = arcpy.Describe(fc_in).spatialReference
... arcpy.env.overwriteOutput = True
...
... flds = ("SHAPE@", fld_start, fld_end, fld_dist)
... lst_polygons = [1]
... with arcpy.da.SearchCursor(fc_in, flds) as curs:
... for row in curs:
... pnt_g = row[0]
... start = row[1]
... end = row[2]
... length = row[3]
... circle = pnt_g.buffer(length)
... pnt = pnt_g.firstPoint
... arrPnts = arcpy.Array()
... arrPnts.add(pnt)
... for bearing in range(int(start), int(end) + 1):
... arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
... polygon = arcpy.Polygon(arrPnts, sr)
... lst_polygons.append(polygon)
...
... arcpy.CopyFeatures_management(lst_polygons, fc_out)
...
... def createPointAtAngleWithBearing(pnt, angle, distance):
... import math
... angle = math.radians(angle)
... dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
... return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)
...
... if __name__ == '__main__':
... main()
...
Runtime error
Traceback (most recent call last):
File "<string>", line 40, in <module>
File "<string>", line 11, in main
AttributeError: DescribeData: Method spatialReference does not exist

Re: Oriented buffers

DarrenWiens2 — Mon, 20 Feb 2017 22:44:12 GMT

It may be having issues with escape characters in the lines where you specify the paths. Try adding an 'r' to denote raw string notation:

e.g.

fc_in = r"C:\Users\ihwm\Documents\ArcGIS\Flood_NT_WA.gdb\points"‍

Re: Oriented buffers

Hayley_DelMaynard — Tue, 21 Feb 2017 00:15:32 GMT

Thanks, Darren! I'm still getting the same message. Could it be because I'm using Arcgis 10.4.1 and that code was written for an earlier version?

>>> import arcpy
...
... def main():
... fc_in = r"C:\Users\ihwm\Documents\ArcGIS\Flood_NT_WA.gdb\points"
... fc_out = r"C:\Users\ihwm\Documents\ArcGIS\Flood_NT_WA.gdb\points2"
...
... fld_start = "fld_start"
... fld_end = "fld_end"
... fld_dist = "fld_dist"
...
... sr = arcpy.Describe(fc_in).spatialReference
... arcpy.env.overwriteOutput = True
...
... flds = ("SHAPE@", fld_start, fld_end, fld_dist)
... lst_polygons = [1]
... with arcpy.da.SearchCursor(fc_in, flds) as curs:
... for row in curs:
... pnt_g = row[0]
... start = row[1]
... end = row[2]
... length = row[3]
... circle = pnt_g.buffer(length)
... pnt = pnt_g.firstPoint
... arrPnts = arcpy.Array()
... arrPnts.add(pnt)
... for bearing in range(int(start), int(end) + 1):
... arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
... polygon = arcpy.Polygon(arrPnts, sr)
... lst_polygons.append(polygon)
...
... arcpy.CopyFeatures_management(lst_polygons, fc_out)
...
... def createPointAtAngleWithBearing(pnt, angle, distance):
... import math
... angle = math.radians(angle)
... dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
... return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)
...
... if __name__ == '__main__':
... main()
...
Runtime error
Traceback (most recent call last):
File "<string>", line 40, in <module>
File "<string>", line 11, in main
AttributeError: DescribeData: Method spatialReference does not exist

Re: Oriented buffers

DanPatterson_Retired — Sat, 11 Dec 2021 13:53:02 GMT

I just tried your code reference to the spatial reference object and it worked... you have a file issue or a disconnect to arcpy for some reason.

inFC
'C:\\Data\\points\\fishnet_label.shp'
sr = arcpy.Describe(inFC).spatialReference
sr.name
'NAD_1983_CSRS_MTM_9'‍‍‍‍‍

Re: Oriented buffers

DarrenWiens2 — Tue, 21 Feb 2017 01:07:04 GMT

Are you sure 'points' is a feature class and not a nonspatial table, that wouldn't have a spatial reference?

Re: Oriented buffers

Hayley_DelMaynard — Tue, 21 Feb 2017 02:43:35 GMT

Hi Darren,

Thanks again for all your help. I started over, taking a subset of my data and creating a feature class layer of 500 points saved in the Default gdb (FloodTestFC).

This is the code I use:

import arcpy
...
... def main():
... fc_in = r"C:\Users\ihwm\Documents\ArcGIS\Default.gdb\FloodTestFC"
... fc_out = r"C:\Users\ihwm\Documents\ArcGIS\Default.gdb\FloodTestFC2"
...
... fld_start = "fld_start"
... fld_end = "fld_end"
... fld_dist = "fld_dist"
...
... sr = arcpy.Describe(fc_in).spatialReference
... arcpy.env.overwriteOutput = True
...
... flds = ("SHAPE@", fld_start, fld_end, fld_dist)
... lst_polygons = [1]
... with arcpy.da.SearchCursor(fc_in, flds) as curs:
... for row in curs:
... pnt_g = row[0]
... start = row[1]
... end = row[2]
... length = row[3]
... circle = pnt_g.buffer(length)
... pnt = pnt_g.firstPoint
... arrPnts = arcpy.Array()
... arrPnts.add(pnt)
... for bearing in range(int(start), int(end) + 1):
... arrPnts.add(createPointAtAngleWithBearing(pnt, bearing, length))
... polygon = arcpy.Polygon(arrPnts, sr)
... lst_polygons.append(polygon)
...
... arcpy.CopyFeatures_management(lst_polygons, fc_out)
...
... def createPointAtAngleWithBearing(pnt, angle, distance):
... import math
... angle = math.radians(angle)
... dist_x, dist_y = (distance * math.cos(angle), distance * math.sin(angle))
... return arcpy.Point(pnt.X + dist_x, pnt.Y + dist_y)
...
... if __name__ == '__main__':
... main()
...

And this is the error message:

Runtime error
Traceback (most recent call last):
File "<string>", line 40, in <module>
File "<string>", line 31, in main
File "c:\program files (x86)\arcgis\desktop10.4\arcpy\arcpy\management.py", line 2335, in CopyFeatures
raise e
RuntimeError: Object: Error in executing tool