¿Extraer coordenadas de vértices poligonales en ArcMap?

Tengo alrededor de una docena de polígonos en una clase de entidad cargada en ArcMap 10, todos en WGS geográfico 1984.

¿Cómo obtengo fácilmente las coordenadas asociadas con cada vértice de cada polígono en esa clase de entidad?

Idealmente, me gustaría que estuvieran bien tabulados en formato de hoja de cálculo.

Use la herramienta Vertices a puntos de entidad dentro de ArcToolbox o si no tiene licencia avanzada, entonces puede usar la herramienta Polígono a punto de ET GeoWizard (herramienta gratuita). Finalmente, en ArcMap use la herramienta Agregar coordenadas XY para generar el valor XY para cada vértice y use 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 un script de Python para escribir características en el archivo de texto que:

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

Nota :

Técnicamente, las herramientas en la caja de herramientas Muestras han quedado en desuso. Todavía están instalados con ArcGIS para que cualquier script existente o herramientas de modelo que haya desarrollado antes del 10 continúen funcionando.

Esta es otra forma de hacerlo usando un da.SearchCursor :

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

with arcpy.da.SearchCursor(fc,['OID@','SHAPE@']) 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
...

Pruebe las herramientas de asistente geográfico de las tecnologías espaciales. Tiene varias herramientas gratuitas que pueden hacer lo que quieras. Intenta obtener las coordenadas del polígono. O polígono a puntos

et geo-magos

El siguiente script de Python (que requiere ArcGIS 10.1 o posterior) utiliza arcpy.dapara tomar un archivo de forma 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 de arco bajo de nivel inferior) . Los ID de objeto y secuencia 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 explode_to_pointsopción en la arcpy.da.FeatureClassToNumPyArrayherramienta

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 = ['OID@', 'Shape@XY']
    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 el polígono que está marcado como duplicado a esta pregunta, ese código está a continuación:

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 = ['OID@', 'Shape@XY']
    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 = ['OID@'] + xy_fields
    with da.UpdateCursor(polygon_copy, u_fields) as cursor:
        oid_ix = cursor.fields.index('OID@')
        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)

Así que 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 archivo de forma (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 se enumeran para cada polígono.

Además, la biblioteca estándar de python (import json) trata los objetos json como diccionarios. Luego, simplemente puede 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é y publicaré la solución.

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 utilicé agregar coordenadas XY desde el mismo menú 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 si estás buscando lo mismo.

Aquí hay una solución en tiempos desesperados:

• Comience a editar la clase de entidad o el archivo de forma
• Seleccione la función de polígono y haga clic con el botón derecho en 'Editar vértices'
• Haga clic derecho en uno de los vértices y seleccione 'Propiedades de croquis'
• Aparecerá un menú desplegable con las coordenadas de los vértices enumerados.
• Tome una captura de pantalla de la lista de coordenadas.
• Pegue la captura de pantalla en su editor de fotos / imágenes favorito y guárdelo como jpeg / png / bmp, etc.
• Google 'OCR en línea gratuito' Elija uno de los resultados (algunos son mejores que otros)
• Sube tu archivo de la captura de pantalla de coordenadas y convierte
• Elija su tipo de archivo de salida (txt, Excel, etc.)
• ¡Compruebe los resultados ya que algunos convertidores OCR son basura!
• Use la adición de datos X, Y en Arcmap para crear un conjunto de datos de puntos.

Este método está bien para conjuntos de datos pequeños, pero la dependencia / limitaciones en los convertidores OCR son la principal preocupación. Usar con precaución.