Tracciare linee parallele all'interno di poligoni (Well Paths) usando ArcGIS Desktop?

Vorrei prendere una classe di funzionalità poligono con più poligoni irregolari e fare in modo che Arc tracci linee parallele all'interno di ciascun poligono. Idealmente, sarebbe bello per Arc capire l'angolo del lato più lungo del poligono e tracciare linee parallele su quel lato, ma per mantenerlo semplice, penso che se potessi inserire un angolo per tutte le linee parallele, che sarebbe più facile.

Quindi l'angolo delle linee, la larghezza tra le linee, la lunghezza min / max e la larghezza del buffer dai lati dei poligoni sono i miei criteri di base.

Immagine allegata se questo aiuta.

Come menziona @cndnflyr, questo può essere scritto in Python.

UI dello strumento di script:

Uscita campione:

# 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

Questo potrebbe essere fatto con Python, ma ci vorrebbe del tempo per scriverlo.

Penso che il modo più rapido per implementarlo senza Python sia avere un file SHP modello di queste linee parallele. Ne hai alcuni se hai bisogno di larghezze variabili e usa solo quello appropriato per quel poligono. Fai in modo che le linee del modello coprano un'area sufficiente per coprire il poligono più grande che incontrerai.

1. Durante la modifica, sposta le linee sul poligono.
2. Usa lo strumento Ruota, sposta il punto di ancoraggio nel punto in cui una linea parallela e il bordo del poligono coincidono e ruota le linee in modo che si agganci al bordo del poligono su cui lo hai allineato.
3. Converti il ​​poligono in una polilinea
4. Tampona la polilinea a qualunque distanza desideri che le linee parallele si trovino dal bordo del poligono.
5. Usa lo strumento Cancella per cancellare le Polilinee coperte dal Bordo Poligono Bufferato
6. Seleziona per posizione tutte le linee che non sono all'interno del poligono ed eliminale. O penso che anche lo strumento Clip funzionerebbe.
7. Seleziona per attributo tutte le linee che sono inferiori a una determinata lunghezza (troppo corte per mantenerle, anche se potresti dover aggiungere un campo e calcolare prima la geometria) e più di una certa lunghezza (troppo lunghe per mantenerle se è quello che vuoi) ), eliminali.
8. Risciacqua e ripeti...

I passaggi da 3 a 7 possono essere modellati, senza dover scrivere alcun codice.

Più o meno lo stesso processo potrebbe essere usato per codificare il processo, ma invece di avere linee modello, potresti avere il codice che disegna le linee ad angolo retto, distanza l'una dall'altra, ecc. Non l'ho fatto per un po ', ma penso che un libreria Python come formosa aiuterebbe. Assicurati solo che copra un'area più ampia del poligono e utilizza gli strumenti per convertire automaticamente in polilinea, buffer, cancellare, selezionare le linee non all'interno del poligono ed eliminarle.