Create Points Along Line at Given Interval
Hello, I'm hoping that someone smarter than me can possibly assist me devising a code snippet to generate points along a line (specifically a "route" line; a line with M values) at a given interval (100 ft). I am basically trying to replicate the labeling from "route" line layer that is visible in ArcGIS Pro using point features so that I may use the point features in ArcGIS Online (as it seems M aware features/functionality in AGOL are not supported).
I know the GP tool "Generate Points Along Line" currently performs this action and works well for a portion of my data where the initial M value (stationing) is a whole number divisible by 100 (EX: 41700, 86000, etc.). Where the issue occurs though is when the initial M value (stationing) is NOT divisible by 100 (41618, 87224, etc.). Using the GP tool causes an offset from the desired "100 ft interval" due to the initial M value (stationing) not starting at a value divisible by 100. Below screenshot was created using existing GP tool.
Basically, when the initial M value is divisible by 100, sequence would read for example: 41700, 41800, 41900, etc. But, when the initial M value is NOT divisible by 100, sequence would read for example: 41618, 41718, 41818, etc. How can I create points at the beginning and end of line as well as at every 100ft interval where the M value (stationing) of the point is divisible by 100. For example ideal output stationing: 41618, 41700, 41800, 41900,...,45000,45100,45121.
@HaydenWelch, thanks for the reply. Unfortunately, neither code block was the solution to my problem; I also tried your comment from the addendum and this also was not the solution. Below are two screenshots that show the results of the suggestions you provided.
The first screenshot shows the results of the code block without the addendum suggestion (both the longer one and the simplified one). The second screenshot is with the added addendum suggestion. The red labeling in both screenshots is the "Measure" or M value's as derived from the line for each point while the black labeling M values needed. Basically the points need to be exactly in the location of the lines labeled station points/tick marks.
As you can see from the first screenshot, just the code block as is (no addendum / modulo), the created points do not fall at the correct interval and are instead at 100 ft intervals starting from the 1st point. The second shot shows that the included addendum gets closer to the solution, but still does not get the exact measures/locations needed (see red labeling vs. black labeling).
From my own testing and python hacking, I originally came to the same conclusion as you regarding the use of the modulo (line.firstPoint.M % measure), but ultimately the results of my own python code block were about the same as the second screenshot. What I was finding though was after returning the first point after the starting point that has an M value divisible by 100 (use the modulo method), the value needed to measure along line (use positionAlongLine function; line 12 and 13) did NOT find a point at the location on the line where the stationing / M value was a value divisible by 100 even though the "dist_to_meas" value + firstPoint.M == M value divisible by 100 (EX: 41700). I'm not sure if its a geometry thing or spatial reference/coordinate system thing, but I couldn't figure out the correct method to find the "dist_to_meas" value to use in the positionAlongLine function that would return a point at the exact station / M value needed.
My Code Block:
#lines_data --> list/array of line data as pulled using SearchCursor
for line in lines_data:
pts_array = [] #empty array to store points
line_geo = line[-1] #get line geometry
firstPoint = line_geo.firstPoint #get first point in line
firstPoint_M = firstPoint.M #get first point station val
lastPoint = line_geo.lastPoint
lastPoint_M = lastPoint.M
pts_array.append(firstPoint)
pts_array.append(lastPoint)
#needs to be exact
dist_to_meas = 100 - (firstPoint_M % 100) #find distance till next station divisible by 100
nextPt = line_geo.positionAlongLine(dist_to_meas,False) #returns point geometry
pts_array.append(nextPt[0])
interval = nextPt[0].M #starting measure
#print(interval)
while interval < lastPoint_M:
interval += 100
dist_to_meas += 100
#print(interval)
nxtPt = line_geo.positionAlongLine(dist_to_meas,False)
pts_array.append(nxtPt[0])Code Block as-is:
Code Block w/ Addendum (modulo):
I'm not sure that's necessarily the issue though. I believe the issue I am running into is due to the fact the first point's M value is a float value and not an int (whole) number; the first point's M value in the polyline is 41617.703125. The next nearest M value along the line divisible by 100 should be found using the following method:
- 100 - (first point M value % 100) --> 100 - (41617.703125 % 100) --> 82.296875 --> lineFeature.positionAlongLine(82.296875) --> should return point at M value 41700.00 (but doesn't).
Is there a level of imprecision that this geometry function has baked in? Are their differences between what an M value is and what is returned by positionAlongLine function (i.e. can't use the return of the modulo as its calculated based on M value as the "measure" distance value in the function)?
Using your suggestion of casting the return from the modulo line from float int did not resolve the issue. The updated function below:
#AGOL community post function:
def get_measures(in_lines: str, out_points: str, measure: int=100):
with(
arcpy.da.SearchCursor(in_lines, ['OID@', 'SHAPE@']) as line_cur,
arcpy.da.InsertCursor(out_points, ['OID@', 'SHAPE@']) as point_cur
):
for oid, line in line_cur:
oid: int
line: arcpy.Polyline
#name = line[1]
fp = arcpy.PointGeometry(line.firstPoint, line.spatialReference)
lp = arcpy.PointGeometry(line.lastPoint, line.spatialReference)
point_cur.insertRow((oid, fp))
first_meas = 100 - int((line.firstPoint.M % measure))
for m in range(int(first_meas), int(line.length), measure):
point_cur.insertRow((oid, line.positionAlongLine(m)))
point_cur.insertRow((oid, lp))The results:
