Determine distance between two lines at multiple locations

Question

We have a number of features that look something like this:

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...)

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)