Czy wyodrębniasz współrzędne wierzchołków wielokąta w ArcMap?

25

Mam około tuzina wielokątów w klasie obiektów załadowanych do ArcMap 10, wszystkie w geograficznym WGS 1984.

Jak łatwo uzyskać współrzędne powiązane z każdym wierzchołkiem każdego wielokąta w tej klasie obiektów?

Idealnie chciałbym, aby były ładnie zestawione w tabelach w formacie arkusza kalkulacyjnego.

hpy
źródło

Odpowiedzi:

12

Działa to ze standardową licencją 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
Bert H.
źródło
4

Jest to inny sposób, aby to zrobić za pomocą 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

Wynikające z ObjectID, X i Y, które można skopiować do Excela:

...
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
...
BERA
źródło
Szybkie pytanie, co się dzieje w części „array1.getObject (0) .getObject (vertice)”?
Rex
@ Rex patrz sekcja pomocy dla Array: pro.arcgis.com/en/pro-app/arcpy/classes/array.htm . Z tablicy pobieram każdy punkt / wierzchołek: i67.tinypic.com/34gstig.jpg
BERA
Świetnie, to pomaga mi zrozumieć to trochę lepiej. Dlaczego więc w tablicy jest tablica, a nie tylko tablica punktów? Czy w pierwszej tablicy jest coś jeszcze? Co dałby Ci array1.getObject (1)?
Rex,
Dzieje się tak, ponieważ otrzymujesz wszystkie części w „wierszu [1] .getPart ()”, dlatego twoja pierwsza tablica to różne części funkcji wieloczęściowej. Więc miałbyś coś poza tablicą1.getObject (0), gdybyś miał funkcję wieloczęściową?
Rex,
3

Wypróbuj narzędzia geo-kreatora z technologii przestrzennych. Ma kilka bezpłatnych narzędzi, które mogą robić, co chcesz. Spróbuj uzyskać współrzędne wielokąta. Lub wielokąt do punktów

i geo-czarodzieje

Brad Nesom
źródło
2

Poniższy skrypt Pythona (który wymaga ArcGIS 10.1 lub nowszego) wykorzystuje arcpy.daplik shapefile jako dane wejściowe i tworzy arkusz kalkulacyjny z wpisem dla każdego wierzchołka w każdym wielokącie obecnym w .shp (i wierzę, że działa z licencjami Arcgis niższego poziomu) . Identyfikator obiektu i sekwencji wiąże punkty z powrotem do określonej pozycji w określonym wielokącie.

H / t do @PaulSmith w tym poście: Zbierz wszystkie punkty polilinii, aby podświetlić explode_to_pointsopcję w arcpy.da.FeatureClassToNumPyArraynarzędziu

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)

Napisałem również skrypt, który dokładnie spełnia wymagania: Wstaw współrzędne wierzchołków w wielokącie, który jest oznaczony jako duplikat tego pytania, kod jest poniżej:

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)
Grant Humphries
źródło
Pierwszy skrypt Pythona robi to, o co prosił hpy! Działa bardzo szybko! Dzięki, Grant Humphries!
ArisA
1

Nie ukończyłem jeszcze rozwiązania, ale wygląda na to, że możesz użyć tego narzędzia:

Konwersja> JSON> Funkcje do JSON.

Spowoduje to konwersję pliku shapefile (w moim przypadku 81 wielokątów) do pliku JSON. Możesz to otworzyć za pomocą edytora tekstu, aby zobaczyć, że rzeczywiście wszystkie wierzchołki są wymienione dla każdego wielokąta.

Ponadto standardowa biblioteka Pythona (import json) traktuje obiekty json jak słowniki. Następnie możesz po prostu przeglądać słowniki, aby zapisać wartości wierzchołków (i wszelkie inne atrybuty, które chcesz) do pliku csv. Jeśli sprawię, że zadziała, wrócę i wyślę soln.

nlb
źródło
0

Potrzebowałem tylko współrzędnych xiy dla polilinii i wielokąta. Użyłem ToolBox -> Narzędzia do zarządzania danymi -> Funkcje -> Funkcja do punktu. Utworzyło to plik kształtu punktu, a następnie użyłem dodania współrzędnych XY z tego samego menu Funkcje, aby wygenerować współrzędne XY. Następnie wyodrębniłem informacje z tabeli atrybutów kształtów do arkusza programu Excel. To rozwiązało mój problem, nie jestem pewien, czy szukasz tego samego.

Shashikiran
źródło
Czy to nie da ci tylko jednego punktu (X, Y) na polilinię / wielokąt, gdy pytanie wymaga jednego punktu (X, Y) dla każdego wierzchołka w każdej polilinii / wielokącie?
PolyGeo
-2

Oto obejście w desperackich czasach:

  • Rozpocznij edycję klasy elementów lub pliku kształtu
  • Wybierz funkcję wielokąta i kliknij prawym przyciskiem myszy, aby „Edytuj wierzchołki”
  • Kliknij prawym przyciskiem myszy jeden z wierzchołków i wybierz „Właściwości szkicu”
  • Pojawi się wysuw z współrzędnymi wymienionych wierzchołków
  • Zrób zrzut ekranu z listą współrzędnych
  • Wklej zrzut ekranu do swojego ulubionego edytora zdjęć / zdjęć i zapisz jako plik jpeg / png / bmp itp
  • Google „Darmowy OCR online” Wybierz jeden z wyników (niektóre są lepsze niż inne)
  • Prześlij plik zrzutu ekranu ze współrzędnymi i przekonwertuj
  • Wybierz typ pliku wyjściowego (txt, Excel itp.)
  • Sprawdź wyniki, ponieważ niektóre konwertery OCR są śmieciami !!!
  • Użyj danych X, Y w Arcmap, aby utworzyć punktowy zestaw danych.

Ta metoda jest odpowiednia dla małych zestawów danych, ale zależność / ograniczenia konwerterów OCR są głównym problemem. Używaj ostrożnie.

Mikrofon
źródło