Dessiner des lignes parallèles à l'intérieur de polygones (Well Paths) à l'aide d'ArcGIS Desktop?

J'aimerais prendre une classe d'entités surfaciques avec plusieurs polygones irréguliers et demander à Arc de tracer des lignes parallèles à l'intérieur de chaque polygone. Idéalement, ce serait bien pour Arc de déterminer l'angle du côté le plus long du polygone et de tracer des lignes parallèles de ce côté, mais pour rester simple, je pense que si je pouvais entrer un seul angle pour toutes les lignes parallèles, cela serait plus facile.

Donc, l'angle de ligne, la largeur entre les lignes, la longueur min / max et la largeur de tampon des côtés des polygones sont mes critères de base.

Image jointe si cela aide.

Comme le mentionne @cndnflyr, cela peut être scripté en Python.

Interface utilisateur de l'outil de script:

Exemple de sortie:

# 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

Cela pourrait être fait avec Python, mais cela prendrait un certain temps pour l'écrire.

Je pense que le moyen le plus rapide de l'implémenter sans Python est d'avoir un fichier SHP modèle de ces lignes parallèles. Ayez-en quelques-uns si vous avez besoin de différentes largeurs, et utilisez simplement celui approprié pour ce polygone. Faites en sorte que les lignes du modèle couvrent suffisamment de surface pour couvrir le plus grand polygone que vous rencontrerez.

1. Pendant l'édition, déplacez les lignes sur le polygone.
2. Utilisez l'outil Rotation, déplacez le point d'ancrage à l'endroit où une ligne parallèle et l'arête du polygone correspondent et faites pivoter les lignes pour qu'elles s'alignent sur l'arête du polygone sur laquelle vous l'avez alignée.
3. Convertir le polygone en polyligne
4. Mettez la polyligne en mémoire tampon quelle que soit la distance à laquelle vous souhaitez que les lignes parallèles soient à partir du bord du polygone.
5. Utilisez l'outil Effacer pour effacer les polylignes couvertes par le bord du polygone tamponné
6. Sélectionnez par emplacement toutes les lignes qui ne sont pas à l'intérieur du polygone et supprimez-les. Ou je pense que l'outil Clip fonctionnerait aussi.
7. Sélectionnez par attribut toutes les lignes qui sont inférieures à une certaine longueur (trop courtes pour être conservées, bien que vous ayez peut-être besoin d'ajouter un champ et de calculer la géométrie en premier), et plus d'une certaine longueur (trop longues à conserver si c'est ce que vous voulez) ), supprime-les.
8. Rincer et répéter ...

Les étapes 3 à 7 peuvent être modélisées, sans avoir à écrire de code.

Le même processus pourrait être utilisé pour coder le processus, mais au lieu d'avoir des lignes de modèle, vous pourriez demander au code de dessiner les lignes au bon angle, à une distance différente, etc. Je ne l'ai pas fait depuis un certain temps, mais je pense qu'un Une bibliothèque Python comme galbée aiderait. Assurez-vous simplement qu'il couvre une zone plus grande que le polygone et utilisez les outils pour convertir automatiquement en polyligne, tamponner, effacer, sélectionner les lignes ne se trouvant pas à l'intérieur du polygone et les supprimer.