We have a number of features that look something like this: Example of polygon feature to be measured

I need to measure the distance between the edges of a track (two lines) for all the tracks, and flag locations where the track width exceeds a given value (15 ft). Currently, an analyst does the process manually:

  • buffer the feature by 7.5 ft, looking for areas where the buffers don't overlap in the middle
  • using the measure tool to confirm width
  • draw lines across to mark divisions
  • draw sub-polygons so feature can be color-coded (green where it doesn't exceed width, red where it does)

I want to automate this process, and it doesn't necessarily need to be done in the same fashion if there's a script. (In other words, it's obvious how to script buffer-making, but not how to script the measuring process, so that probably wouldn't be the process if I Pythonize this.) I hope to get suggestions/framework for how (methods/approaches/tools, not code) to proceed with this.

We have Arc 10.1, all extensions.

EDIT: Buffering to those areas where the original buffers don't meet, as suggested in @radouxju's solution, will not work the way I need because it ends up overestimating the total area of "too-wide" tracks. We want to have linear breaks between the different width class sections (see red, below), and buffering will have rounded breaks (see dashed purple, below) which increases the size of the too-wide segments.

Unfortunately, this accuracy matters. (I've argued this issue -- they got the boundary data from GPS points while walking along the track edges, which introduces its own set of inaccuracies, but they still want the results so we'll just do what we can with what we've got...)

enter image description here

1 Answer 1


If you convert your tracks to polygons (feature to polygons), you can then apply a negative buffer on all your track and it will remove the parts which are too narrow. Then you expand the resulting polygons again with a positive buffer of the same value and you compute the union between those two layers. You can then color code the result based on the attribute table (null values for the fields originated from the second layer means that it was too narrow)

EDIT: for more straight lines, you can erase the buffers where you have "not to narrow polygons" (green minus purple). This will yield convex rounded sides on your green polygons. You can fill this as a straight line using "minimum bounding geometry" for a convex hull, and intersect the convex hull with the original polygon layer.

I don't think that a measurement would be useful with this approach, but "minimum bounding geometry > rectangle by width" could help you in this case (after the union)

  • Hmm. This doesn't exactly work as is (buffering the not-too-narrow polygons creates a round inclusion and I need flat/linear edges) but maybe convert the not-too-narrow polygon to line features and then buffer those...
    – Erica
    Commented May 7, 2014 at 13:33
  • DARN. Unfortunately it doesn't work quite right that way either
    – Erica
    Commented May 7, 2014 at 13:42
  • you could build a convex hull (minimum bounding geometry) on the "too-narrow-polygons" to get straight lines
    – radouxju
    Commented May 7, 2014 at 13:44
  • The minimum bounding rectangles will still be at the edge of the buffer's curve, though, inflating the size of the polygon. Maybe if I bound the original buffers, then inflate the buffers and intersect the result. I have to go write some scripts, I'll let you know! :)
    – Erica
    Commented May 7, 2014 at 13:54
  • Thanks for the edit, the minimum bounding convex hull definitely worked. (Had a heck of a time getting it to work properly before I realized the problem was multipart features...)
    – Erica
    Commented May 7, 2014 at 15:57

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.