Déplacer / compenser des emplacements de points à l'aide d'ArcPy ou de ModelBuilder?

J'ai un certain nombre de couches CAD non géoréférencées (voir cette question ) qui ont des fonctionnalités d'annotation de texte. J'ai créé un modèle pour convertir le texte en points, mais après avoir converti l'annotation en une classe de points, je constate que les points d'ancrage du texte CAD ne coïncident pas avec le centre du texte CAD (qui est l'endroit où les points appartiennent).

Par conséquent, je voudrais programmer (en utilisant ArcPy ou ModelBuilder) [déplacer] une entité par rapport à son emplacement actuel (delta x, y) en utilisant une valeur X, Y mesurée que je fournirai.

Cela me permettrait de ramener les points SIG à leur place, au lieu du point d'ancrage CAD décalé.

Comment puis-je accomplir cette tâche?

@PolyGeo a donné une excellente réponse en utilisant SHAPE @ XY IN 10.1, mais actuellement j'utilise 10.0. Des idées 10,0?

Ce code doit le faire à l'aide du jeton SHAPE @ XY fourni avec arcpy.da.UpdateCursor dans ArcGIS 10.1.

import arcpy
# Set some variables
fc = r"C:\temp\test.gdb\testFC"
fc2 = r"C:\temp\test.gdb\testFCcopy"
xOffset = 0.001
yOffset = 0.001
# Code to make a copy which will have its coordinates moved (and can be compared with original)
if arcpy.Exists(fc2):
    arcpy.Delete_management(fc2)
arcpy.Copy_management(fc,fc2)
# Perform the move
with arcpy.da.UpdateCursor(fc2, ["SHAPE@XY"]) as cursor:
    for row in cursor:
        cursor.updateRow([[row[0][0] + xOffset,row[0][1] + yOffset]])

Le modèle de codage utilisé ici provient d' ArcPy Café .

Je remercie @ artwork21 de m'avoir conduit à ma solution finale. En fait, j'ai trouvé un script presque complet dans l'article d'aide en ligne d'ArcGIS 10.0 intitulé « Exemples de calcul de champ », répertorié sous la sous-catégorie « Échantillons de code - géométrie » et « Pour une classe d'entités points, déplacez la coordonnée x de chaque point de 100 »

Le script final que j'ai utilisé dans l'outil "Calculer le champ" de ModelBuilder était:

Expression:

shiftXYCoordinates(!SHAPE!,%ShiftX%,%ShiftY%)

où ShiftX et ShiftY sont des variables (en tant que paramètres) définies sur le canevas ModelBuilder.

Type d'expression:

PYTHON_9.3

Bloc de code:

def shiftXYCoordinates(shape,x_shift,y_shift):
   point = shape.getPart(0)
   point.X += float(x_shift)
   point.Y += float(y_shift)
   return point

Étant donné que tous les modèles fonctionnent sur un ensemble sélectionné, vous devriez également pouvoir le créer en tant qu'outil générique qui fonctionnera en conjonction avec d'autres modèles / outils dans d'autres sessions de création de modèles. Le modèle très simple que j'ai créé (en tant que "plugin" vers d'autres modèles pour décaler les valeurs de coordonnées) ressemble à ceci. De cette façon, je peux contrôler le décalage sur une base d'ensemble de sélection (comme défini dans d'autres modèles):

Cela a fonctionné comme un charme, merci à tous pour votre contribution!

Vous pouvez également utiliser ce script de calculatrice de champ pour déplacer les emplacements d'entités:

def XYsetVALUE( shape, X_value, Y_value): 
  myMoveX = 0.001
  myMoveY = 0.001
  point = shape.getPart(0) 
  point.X = X_value + myMoveX
  point.Y = Y_value + myMoveY
  return point 

XYsetVALUE (! SHAPE !,! X_COORD !,! Y_COORD!)

Vous pouvez inclure une méthode de calcul de champ supplémentaire dans votre modèle à l'aide de la fonction ci-dessus.

J'ai adapté la solution pour déplacer / décaler des points dans une certaine direction (angle) et une distance donnée.

Ressemble à:

def shiftXYCoordinates(shape,angle,distance):
point = shape.getPart(0)
point.Y += distance * math.cos(math.radians(angle))
point.X += distance * math.sin(math.radians(angle))
return point

et être appelé comme shiftXYCoordinates (! SHAPE !,! Angle!, 5000), si vous avez un "angle" de champ pour vos entités ponctuelles (ou avec une constante bien sûr). L'angle doit être donné en degrés décimaux. 0 se déplacera "vers le haut", 90 "vers la droite", etc.

Assurez-vous également de sélectionner le nom du champ «Forme» avant de lancer :)

(Solution testée dans ArcMap 10.0 SP5)

Comme vous pouvez le voir, c'est beaucoup plus facile dans 10.1 lorsque vous avez accès aux jetons de curseur.

import arcpy
# Code to move features in copy of same dataset
fc = r"C:\temp\test.gdb\testFC"
fc2 = r"C:\temp\test.gdb\testFCcopy"
xOffset = 0.001
yOffset = 0.001
if arcpy.Exists(fc2):
    arcpy.Delete_management(fc2)
arcpy.Copy_management(fc, fc2)

shape = arcpy.Describe(fc2).ShapeFieldName

cursor = arcpy.UpdateCursor(fc2)
for row in cursor:    
    point = row.getValue(shape).getPart()
    row.setValue(shape, arcpy.Point(point.X + xOffset, point.Y + yOffset))
    cursor.updateRow(row) 

del point, row, cursor

Cela fonctionne pour 10.0:

# Featureclass here
FC = r'featureclass'

fcount = 0
shapefield = arcpy.Describe(FC).shapeFieldName
featureUpdate = arcpy.UpdateCursor(FC)
for f in featureUpdate:
    # Hard coded shifts but easy enough to set up a lookup function if needed
    sLon = 0.001
    sLat = 0.001
    # Optional but I like to count to see where it is at in the process
    if fcount % 1000 == 0:
        print('Updating feature %s...' %(fcount))
    # Get the original value
    cF = f.getValue(shapefield)
    cPNT = cF.getPart()
    # Create a new point with the shifted value
    sPNT = arcpy.Point(cPNT.X - sLon, cPNT.Y - sLAT)
    # Set the shapefield to the new point and update feature
    f.setValue(shapefield, sPNT)
    featureUpdate.updateRow(f)
    fcount += 1
del featureUpdate