¿Extraer las coordenadas de los vértices de polígonos en ArcMap?

Use Característica de los vértices a los puntos en ArcToolbox o si no tiene una licencia Advanced, puede usar la herramienta Polygon to Point de ET Geowizard ( herramienta gratuita). Finalmente, en ArcMap use la Agregar coordenadas XY herramienta para generar el valor XY para cada vértice y usar Table to Excel para generar una hoja de cálculo.

Esto funciona con una licencia estándar de ArcGIS:

desc = arcpy.Describe(fcl)
shapefieldname = desc.ShapeFieldName

gebieden = arcpy.UpdateCursor(fcl)

for gebied in gebieden:
    polygoon = gebied.getValue(shapefieldname)
    for punten in polygoon:
        for punt in punten:
            print punt.X, punt.Y

Hay una caja de herramientas de muestra que incluye una Escribir características en el archivo de texto secuencia de comandos de python que:

  

Escribe las coordenadas de las características en un archivo de texto.

Nota :

  

Técnicamente, las herramientas en la caja de herramientas de Muestras han sido desaprobadas.   Todavía se instalan con ArcGIS para que cualquier script o   las herramientas modelo que desarrolló antes del 10 siguen funcionando.

Pruebe las herramientas de geo-wizard de tecnologías espaciales. Tiene varias herramientas gratuitas que pueden hacer lo que quieras.  Prueba las coordenadas del polígono. O polígono a puntos

et geo-wizards

Esta es otra forma de hacerlo utilizando un da .Cursor de búsqueda :

import arcpy
fc=r'C:\TEST.gdb\polygons123'

with arcpy.da.SearchCursor(fc,['[email protected]','[email protected]']) as cursor:
    for row in cursor:
        array1=row[1].getPart()
        for vertice in range(row[1].pointCount):
            pnt=array1.getObject(0).getObject(vertice)
            print row[0],pnt.X,pnt.Y

Resultando en ObjectID, X e Y que se pueden copiar a Excel:

...
1 537505.894287 6731069.60889
1 537533.516296 6731078.20947
1 537555.316528 6731082.53589
1 537562.501892 6731085.47913
1 537589.395081 6731070.52991
1 537617.062683 6731058.29651
2 537379.569519 6729746.16272
2 537384.81311 6729746.06012
2 537396.085327 6729748.62311
2 537404.065674 6729752.75311
2 537425.145325 6729773.72931
2 537429.842102 6729777.07129
2 537442.971313 6729780.10651
2 537450.27533 6729780.51611
...

El siguiente script de python (que requiere ArcGIS 10.1 o posterior) utiliza arcpy.da para tomar un shapefile como entrada y crear una hoja de cálculo con una entrada para cada vértice en cada polígono presente en el .shp (y creo que funciona con licencias arcgis de nivel inferior). Los identificadores de objetos y secuencias vinculan los puntos a una posición específica en un polígono específico.

H / t a @PaulSmith en esta publicación: Obtenga todos los puntos de una polilínea para resaltar la opción explode_to_points en la herramienta arcpy.da.FeatureClassToNumPyArray

import os
import csv
import arcpy
from os import path
from arcpy import da
from arcpy import env

env.overwriteOutput = True
env.workspace = '/folder/containing/your/shp/here'

polygon_shp = path.join(env.workspace, 'your_shapefile_name.shp')
vertex_csv_path = 'your/csv/path/here/poly_vertex.csv'

def getPolygonCoordinates(fc):
    """For each polygon geometry in a shapefile get the sequence number and
    and coordinates of each vertex and tie it to the OID of its corresponding
    polygon"""

    vtx_dict = {}
    s_fields = ['[email protected]', '[email protected]']
    pt_array = da.FeatureClassToNumPyArray(polygon_shp, s_fields, 
        explode_to_points=True)

    for oid, xy in pt_array:
        xy_tup = tuple(xy)
        if oid not in vtx_dict:
            vtx_dict[oid] = [xy_tup]
        # this clause ensures that the first/last point which is listed
        # twice only appears in the list once
        elif xy_tup not in vtx_dict[oid]:
            vtx_dict[oid].append(xy_tup)


    vtx_sheet = []
    for oid, vtx_list in vtx_dict.iteritems():
        for i, vtx in enumerate(vtx_list):
            vtx_sheet.append((oid, i, vtx[0], vtx[1]))

    writeVerticesToCsv(vtx_sheet)

def writeVerticesToCsv(vtx_sheet):
    """Write polygon vertex information to csv"""

    header = (
        'oid',          'sequence_id', 
        'x_coordinate', 'y_coordinate')

    with open(vertex_csv_path, 'wb') as vtx_csv:
        vtx_writer = csv.writer(vtx_csv)
        vtx_writer.writerow(header)

        for row in vtx_sheet:
            vtx_writer.writerow(row)

getPolygonCoordinates(polygon_shp)

También escribí un script que aborda específicamente los requisitos de: Insertar coordenadas de vértices en polígono que está marcado como duplicado a esta pregunta, el código está debajo:

import os
import arcpy
from os import path
from arcpy import da
from arcpy import env
from arcpy import management

env.overwriteOutput = True
env.workspace = '/folder/containing/your/shp/here'

polygon_shp = path.join(env.workspace, 'your_shapefile_name.shp')
file_gdb = 'your/file/gdb/path/here/temp.gdb'

def addVerticesAsAttributes(fc):
    """Add the x,y coordinates of vertices as attributes to corresponding 
    features.  The coordinates will be in the order the appear in the geometry"""

    polygon_copy = createGdbFcCopy(fc)

    vtx_dict = {}
    s_fields = ['[email protected]', '[email protected]']
    pt_array = da.FeatureClassToNumPyArray(polygon_copy, s_fields, 
        explode_to_points=True)

    for oid, xy in pt_array:
        xy_tup = tuple(xy)
        if oid not in vtx_dict:
            vtx_dict[oid] = [xy_tup]
        # this clause ensures that the first/last point which is listed
        # twice only appears in the list once
        elif xy_tup not in vtx_dict[oid]:
            vtx_dict[oid].append(xy_tup)

    # find that largest number of points that exist within a polygon to determine 
    # the number of fields that need to be added to the shapefile
    max_vertices = 0
    for vtx_list in vtx_dict.values():
        if len(vtx_list) > max_vertices:
            max_vertices = len(vtx_list)

    xy_fields = addXyFields(polygon_copy, max_vertices)

    u_fields = ['[email protected]'] + xy_fields
    with da.UpdateCursor(polygon_copy, u_fields) as cursor:
        oid_ix = cursor.fields.index('[email protected]')
        for row in cursor:
            xy_ix = oid_ix + 1
            for vtx in vtx_dict[row[oid_ix]]:
                for coord in vtx:
                    row[xy_ix] = coord
                    xy_ix += 1

            cursor.updateRow(row)

def createGdbFcCopy(fc):
    """Create copy of the input shapefile as a file geodatabase feature class,
    because a huge number of fields may be added to the fc this preferable to shp"""

    if not arcpy.Exists(file_gdb):
        management.CreateFileGDB(path.dirname(file_gdb), 
            path.basename(file_gdb))

    polygon_copy = path.join(file_gdb, 'polygon_shp_copy')
    management.CopyFeatures(polygon_shp, polygon_copy)
    return polygon_copy

def addXyFields(fc, vtx_count):
    """Add fields to the feature class that will hold the x, y coordinates for each
    vertex, the number of fields is twice the number of most vertices in any polygon"""

    field_list = []
    f_type = 'DOUBLE'
    for i in range(1, vtx_count+1):
        f_names = ['x{0}'.format(i), 'y{0}'.format(i)]
        for fn in f_names:
            management.AddField(fc, fn, f_type)

        field_list.extend(f_names)

    return field_list

addVerticesAsAttributes(polygon_shp)

Todavía no he completado la solución, pero parece que puedes usar esta herramienta:

Conversión > JSON > Características a JSON.

Esto convertirá su shapefile (en mi caso, 81 polígonos) en un archivo JSON. Puede abrir esto con un editor de texto para ver que, de hecho, todos los vértices están listados para cada polígono.

Además, la biblioteca estándar de python (import json) trata los objetos json como diccionarios. Luego, puede simplemente recorrer sus diccionarios para escribir los valores de vértice (y cualquier otro atributo que desee) en un archivo csv. Si lo hago funcionar, volveré & publicar la soln.

Solo necesitaba las coordenadas x e y para la polilínea y el polígono. Utilicé ToolBox - > Herramientas de gestión de datos - > Características - > Característica a punto. Esto creó un archivo de forma de punto, luego usé agregar coordenadas XY desde el mismo menú de Características para generar coordenadas XY. Luego extraje la información de la tabla de atributos de formas en una hoja de Excel. Esto resolvió mi problema, no estoy seguro de si está buscando lo mismo.

Aquí hay una solución alternativa en tiempos desesperados:

• Comience a editar la clase de entidad o shapefile
• Seleccione la función de polígono y haga clic con el botón derecho en 'Editar vértices'
• Haga clic con el botón derecho en uno de los vértices y seleccione 'Propiedades de bosquejo'
• Aparecerá un desplegable con las coordenadas de los vértices listados
• Tome una captura de pantalla de la lista de coordenadas
• Pega la captura de pantalla en tu editor de foto / foto favorito y guardar como un jpeg / png / bmp etc
• Google 'OCR en línea gratis' Elija uno de los resultados (algunos son mejor que otros)
• Suba su archivo de la captura de pantalla de coordenadas y convierta
• Elija su tipo de archivo de salida (txt, Excel, etc.)
• ¡Verifique los resultados ya que algunos convertidores de OCR son basura!
• Use los datos de agregar X, Y en Arcmap para crear un conjunto de datos de puntos.

Este método es correcto para conjuntos de datos pequeños, pero la principal preocupación es la dependencia / limitaciones de los convertidores de OCR. Utilizar con precaución.