Extraindo número de vértices em cada polígono?

Eu tenho o ArcGIS Desktop 10.2 e meu desafio é como extrair os vértices numéricos em cada polígono para todos os recursos como este:

Eu tenho muitos pacotes na minha classe de recurso e quero extrair o número de vértices para todos os recursos separadamente. Quero exibir as coordenadas XY para todos os vértices.

Para obter mais informações, eu só quero converter vértices para cada polígono e exibir o número de cada vértices com um número, então se eu tiver um polígono e ele tiver 4 vértices, um desejo de converter polígono em vértices, exibirei o número de vértices como este (1,2,3,4,5), exibindo xy para cada vértice, acho que o verdadeiro desafio é: como converter todo polígono em vértices e fazer cada número de vértices a partir de 1 número.

O código abaixo combina as outras respostas e adiciona um pouco ao número dos vértices.

import arcpy
arcpy.env.workspace = "in_memory"
#paths
fc = r"...\polygons"
fc_out = r"...\vertices"
arcpy.MakeFeatureLayer_management(fc, "lyr")
# add fields if needed
for FIELD in ["DRAW_ORDER", "COUNT"]:
    if FIELD not in [field.name for field in arcpy.ListFields(fc)]:
        try:
            arcpy.AddField_management("lyr", FIELD, "SHORT")
        except Exception as e:
            print e
# get the number of points minus overlapping (@dmahr - GSE)
arcpy.CalculateField_management("lyr", "COUNT", "!Shape!.pointCount-!Shape!.partCount", "PYTHON")
# dict to iterate and check count
OIDS = {}
for row in arcpy.da.SearchCursor("lyr", ["OBJECTID", "COUNT"]):
    OIDS[row[0]] = row[1]
del row
# get vertices as points and add XY (@Aaron - GSE)
arcpy.FeatureVerticesToPoints_management("lyr", fc_out)
arcpy.AddXY_management(fc_out)
# start adding a number to the points
for OID in OIDS:
    order_count = 1
    rows = arcpy.da.UpdateCursor(fc_out, ["DRAW_ORDER", "COUNT"], "ORIG_FID = %d"%OID)
    for row in rows:
        # will leave the overlapping as NULL
        if order_count <= OIDS[OID]:
            row[0] = order_count
            rows.updateRow(row)
            order_count += 1
##        # this can set the overlapping to 0 or some unique value (999)
##        else:
##            row[0] = 0
##            rows.updateRow(row)

Os pontos são rotulados em ordem de desenho. O último ponto (abaixo do primeiro) não terá rótulo e poderá ser excluído selecionando todos os pontos com valores "DRAW_ORDER" nulos ou únicos, se não forem necessários para a reconstrução. Uma consulta de definição pode ser usada para remover os pontos sobrepostos da exibição.

Dados XY estão presentes, mas deixarei isso para seus desejos de rotulagem / exibição. Consulte a resposta de Aaron sobre como adicionar um campo XY para rotular.

Eu também estava brincando com o FeatureClass em um array numpy, mas terminei isso primeiro.

A maneira mais fácil de fazer isso é adicionar um novo campo inteiro à tabela de atributos da camada de parcelas. Em seguida, execute a calculadora de campo com a seguinte expressão:

!Shape!.pointCount-!Shape!.partCount

O !Shape!.pointCountretorna o número total de vértices no recurso. No entanto, o primeiro vértice de cada parte é repetido no final, para fechar o recurso. Para lidar com isso, subtraia um vértice para cada parte usando -!Shape!.partCount.

Observe que você precisará usar o analisador Python para que essa expressão funcione.

O dmahr forneceu uma boa solução para contar vértices. Para uma maneira não programática de rotular cada ponto com as cordas XY, tente o seguinte fluxo de trabalho:

1. Recurso Vértices para Pontos
2. Adicione dois novos campos (digite: double) no novo ponto FC "X", "Y"
3. Calcular geometria. Clique com o botão direito do mouse no campo> Calcular geometria ...> Coordenada X do ponto (repita para o campo Y)
4. Adicione outro campo "XY" (digite: Texto)

5. Calcular o campo "XY" na calculadora de campos, onde XY =

   str (! x!) + "," + str (! y!)

6. Recursos de etiqueta. Clique com o botão direito do mouse na camada> Rótulos> Campo do rótulo: XY

Isso produz os seguintes resultados:

Você também pode executar essas ações programaticamente usando explode_to_pointscom um cursor de pesquisa (como início).

Desconstrua um recurso em seus pontos ou vértices individuais. Se explode_to_points estiver definido como True, um recurso multiponto com cinco pontos, por exemplo, será representado por cinco linhas.

(O valor padrão é falso)

arcpy.da.SearchCursor (in_table, field_names, {where_clause}, {spatial_reference}, {explode_to_points}, {sql_clause})

Se alguém não deseja calcular um novo campo e apenas deseja recuperar vários vértices por camada rapidamente (para propósitos de generalização, ao expor os conjuntos de dados na Web), é possível criar uma ferramenta de script personalizada dentro de um caixa de ferramentas ou exponha o código como um suplemento Python.

Código da ferramenta de script personalizado:

import arcpy
in_fc = arcpy.GetParameterAsText(0)

features = [feature[0] for feature in arcpy.da.SearchCursor(in_fc,"SHAPE@")]
count_vertices = sum([f.pointCount-f.partCount for f in features])
arcpy.AddMessage("***************************************")
arcpy.AddMessage("Number of vertices in the layer: {0}".format(count_vertices))
arcpy.AddMessage("***************************************")

Código de suplemento Python (selecione uma camada no sumário para contar vértices):

import arcpy
import pythonaddins

arcpy.env.overwriteOutput = True
mxd = arcpy.mapping.MapDocument("current")
in_fc = pythonaddins.GetSelectedTOCLayerOrDataFrame()

features = [feature[0] for feature in arcpy.da.SearchCursor(in_fc,"SHAPE@")]
count_vertices = sum([f.pointCount-f.partCount for f in features])

pythonaddins.MessageBox(count_vertices, 'Number of vertices in {0}'.format(in_fc.name), 0)