Zeichnen paralleler Linien in Polygonen (Well Paths) mit ArcGIS Desktop?

Ich möchte eine Polygon-Feature-Class mit mehreren unregelmäßigen Polygonen verwenden und Arc parallele Linien innerhalb jedes Polygons zeichnen lassen. Im Idealfall wäre es für Arc schön, den Winkel der längsten Seite des Polygons herauszufinden und parallele Linien zu dieser Seite zu zeichnen, aber um es einfach zu halten, denke ich, wenn ich nur einen Winkel für alle parallelen Linien eingeben könnte, das wäre einfacher.

Linienwinkel, Breite zwischen Linien, Min / Max-Länge und Pufferbreite von den Seiten der Polygone sind meine Grundkriterien.

Bild angehängt, wenn das hilft.

Wie @cndnflyr erwähnt, kann dies in Python geschrieben werden.

Benutzeroberfläche des Skript-Tools:

Beispielausgabe:

# import libraries
import arcpy

# set input/output parameters
polyFC = arcpy.GetParameterAsText(0)        # input polygons
outParallel = arcpy.GetParameterAsText(1)   # output parallel lines
lineSpacing = arcpy.GetParameterAsText(2)   # line spacing
buffDist = arcpy.GetParameterAsText(3)      # inner buffer distance

# parse numbers from parameters
lineSpaceNum = float(lineSpacing.split(' ')[0])
buffNum = float(buffDist.split(' ')[0])

# establish spatial reference
desc = arcpy.Describe(polyFC)
SR = desc.spatialReference

# set overwrite environment
arcpy.env.overwriteOutput = True
arcpy.env.outputCoordinateSystem = SR

parallels = []
# loop through each input shape
for row in arcpy.da.SearchCursor(polyFC, ["SHAPE@"], spatial_reference=SR):

    # create inner buffer
    polyBuff = row[0].buffer(buffNum * -1)

    # create hull rectangle to establish a rotated area of interest
    coordSplit = row[0].hullRectangle.split(' ')

    # collect corner coordinates
    coordList = arcpy.Array([arcpy.Point(coordSplit[0],coordSplit[1]),arcpy.Point(coordSplit[2],coordSplit[3]),arcpy.Point(coordSplit[4],coordSplit[5]),arcpy.Point(coordSplit[6],coordSplit[7]),arcpy.Point(coordSplit[0],coordSplit[1])])

    # create lines from hull rectangle
    currentLines = []
    for pointNum in range(0,4):
        arcpy.Array([coordList.getObject(pointNum),coordList.getObject(pointNum+1)])
        hullRecLine = arcpy.Polyline(arcpy.Array([coordList.getObject(pointNum),coordList.getObject(pointNum+1)]))
        currentLines.append(hullRecLine)

    # compare first and second line to determine if first line is short or long
    firstLong = 0
    if currentLines[0].length > currentLines[1].length:
        firstLong = 1

    # calculate number of points needed along short axis
    numPoints = int(math.floor(currentLines[firstLong].length/lineSpaceNum))

    # create and join points to create parallel lines
    for point in range(1,numPoints+1):
        shortPoint1 = currentLines[firstLong].positionAlongLine(lineSpaceNum*point)
        shortPoint2 = currentLines[firstLong + 2].positionAlongLine(currentLines[firstLong + 2].length - (lineSpaceNum*point))
        parallel = arcpy.Polyline(arcpy.Array([shortPoint1.centroid,shortPoint2.centroid]), SR)

        # intersect parallel lines with buffer
        parallelBuff = parallel.intersect(polyBuff,2)
        parallels.append(parallelBuff)

# write geometries to disk
arcpy.CopyFeatures_management(parallels, outParallel)

# add to map
mxd = arcpy.mapping.MapDocument("CURRENT")
dataFrame = arcpy.mapping.ListDataFrames(mxd, "*")[0]
addLayer = arcpy.mapping.Layer(outParallel)
arcpy.mapping.AddLayer(dataFrame, addLayer)

del row

Dies könnte mit Python geschehen, aber es würde einige Zeit dauern, es zu schreiben.

Ich denke, der schnellste Weg, es ohne Python zu implementieren, besteht darin, eine SHP-Vorlagendatei dieser parallelen Linien zu haben. Haben Sie ein paar, wenn Sie unterschiedliche Breiten benötigen, und verwenden Sie einfach die entsprechende für dieses Polygon. Stellen Sie sicher, dass die Vorlagenlinien genügend Fläche abdecken, um das größte Polygon abzudecken, auf das Sie stoßen.

1. Bewegen Sie während der Bearbeitung die Linien über das Polygon.
2. Verwenden Sie das Werkzeug Drehen, verschieben Sie den Ankerpunkt an die Stelle, an der eine parallele Linie und die Polygonkante übereinstimmen, und drehen Sie die Linien so, dass sie an der Polygonkante einrasten, an der Sie sie ausgerichtet haben.
3. Konvertieren Sie das Polygon in eine Polylinie
4. Puffern Sie die Polylinie in dem Abstand, in dem die parallelen Linien von der Polygonkante entfernt sein sollen.
5. Verwenden Sie das Löschwerkzeug, um die Polylinien zu löschen, die von der gepufferten Polygonkante abgedeckt werden
6. Wählen Sie nach Position alle Linien aus, die sich nicht im Polygon befinden, und löschen Sie sie. Oder ich denke, das Clip-Tool würde auch funktionieren.
7. Wählen Sie nach Attribut alle Linien aus, die kleiner als eine bestimmte Länge sind (zu kurz, um sie beizubehalten, obwohl Sie möglicherweise zuerst ein Feld hinzufügen und die Geometrie berechnen müssen), und mehr als eine bestimmte Länge (zu lang, um sie beizubehalten, wenn Sie dies wünschen ), Lösche sie.
8. Spülen und wiederholen ...

Die Schritte 3 bis 7 können modelliert werden, ohne dass Code geschrieben werden muss.

Der gleiche Prozess könnte zum Codieren des Prozesses verwendet werden, aber anstatt Vorlagenzeilen zu haben, könnte der Code die Linien im richtigen Winkel, im Abstand voneinander usw. zeichnen. Ich habe dies eine Weile nicht getan, aber ich denke a Python-Bibliothek wie Shapely würde helfen. Stellen Sie einfach sicher, dass es einen größeren Bereich als das Polygon abdeckt, und verwenden Sie die Werkzeuge, um automatisch in Polylinien zu konvertieren, zu puffern, zu löschen, die Linien auszuwählen, die sich nicht im Polygon befinden, und sie zu löschen.