Making a join between a table and many Feature classes and being able to export them

JuanManuelCruzHerrera — Tue, 02 Jul 2024 13:53:12 GMT

Hola . Llevo días intentando hacer un join entre Feature Class y una tabla para que los datos de la tabla se queden en la FC, primero intenté creando los campos vacíos en la FC y al hacer el join los datos de la tabla pasaran a la FC antes de quitar el Join pero no me daba la información y luego intenté crear una nueva FC con el join pero sigue sin coger la tabla. Lo último que intenté fue arcpy.management.MakeFeatureLayer y luego arcpy.conversion.ExportFeatures pero tampoco funcionó y finalmente hice arcpy.management.AddJoin(fc_name, "Codigo_Municipal_Catastral", table, "Codigo_Municipal_Catastral", "KEEP_ALL")
print(f"Join hecho entre '{fc_name}' y '{table}' con tipo 'KEEP_ALL'")

# Crear una capa temporal
arcpy.management.MakeFeatureLayer(fc_name, layer_name)
print(f"Capa temporal '{layer_name}' creada a partir de la clase de entidad")

# Guarde la capa temporal como un archivo de capa (.lyrx)
arcpy.management.SaveToLayerFile(layer_name, layer_file, "RELATIVE")
print(f"Capa guardada como archivo de capa '{layer_file}'")
pero tampoco me da los datos de la tabla en la nueva clase de entidad.

Dejo algunos de los guiones aquí

importar arcpy
importar sistema operativo

def realizar_join_y_exportar(gdb_destino, prefijo, sufijo, dataset, tabla):
"""
Realiza un join entre los feature classes y la tabla 'cod_catastrales' y exporta el resultado a un nuevo feature class.
"""
arcpy.env.workspace = f"{gdb_destino}\\{dataset}"
feature_classes = arcpy.ListFeatureClasses(f"{sufijo}*")

for fc in feature_classes:
nombre_fc = f"{gdb_destino}\\{dataset}\\{fc}"
nuevo_fc = f"{gdb_destino}\\{dataset}\\{prefijo}{fc[len(sufijo):]}"
layer_name = f"layer_{fc}"
layer_file = os.path.join(gdb_destino, f"{layer_name}.lyrx")

if arcpy.Exists(nombre_fc):
# Realizar Join con la opción KEEP_ALL
arcpy.management.AddJoin(nombre_fc, "Codigo_Municipal_Catastral", tabla, "Codigo_Municipal_Catastral", "KEEP_ALL")
print(f"Join realizado entre '{nombre_fc}' y '{tabla}' con tipo 'KEEP_ALL'")

# Crear una capa temporal
arcpy.management.MakeFeatureLayer(nombre_fc, layer_name)
print(f"Capa temporal '{layer_name}' creada desde el feature class")

# Guardar la capa temporal como archivo de capa (.lyrx)
arcpy.management.SaveToLayerFile(layer_name, layer_file, "RELATIVE")
print(f"Capa guardada como archivo de capa '{layer_file}'")

# Cargar la capa desde el archivo de capa y exportarla a un nuevo feature class
arcpy.management.MakeFeatureLayer(layer_file, layer_name)
arcpy.conversion.FeatureClassToFeatureClass(layer_name, os.path.dirname(nuevo_fc), os.path.basename(nuevo_fc))
print(f"Feature class exportado a '{nuevo_fc}'")

def verificar_elementos(gdb_destino, prefijo, sufijo, dataset):
"""
Verifica la cantidad de elementos en los feature classes originales y los nuevos feature classes.
"""
arcpy.env.workspace = f"{gdb_destino}\\{dataset}"
feature_classes_orig = arcpy.ListFeatureClasses(f"{sufijo}*")
feature_classes_new = arcpy.ListFeatureClasses(f"{prefijo}*")

for fc_orig, fc_new in zip(feature_classes_orig, feature_classes_new):
nombre_fc_orig = f"{gdb_destino}\\{dataset}\\{fc_orig}"
nombre_fc_new = f"{gdb_destino}\\{dataset}\\{fc_new}"

if arcpy.Exists(nombre_fc_orig) and arcpy.Exists(nombre_fc_new):
count_orig = arcpy.management.GetCount(nombre_fc_orig)[0]
count_new = arcpy.management.GetCount(nombre_fc_new)[0]
print(f"Feature class original: '{nombre_fc_orig}' - Elementos: {count_orig}")
print(f"Feature class nuevo: '{nombre_fc_new}' - Elementos: {count_new}")
if count_orig == count_new:
print(f"Verificación exitosa: La cantidad de elementos coincide entre '{nombre_fc_orig}' y '{nombre_fc_new}'.\n")
else:
print(f"Error de verificación: La cantidad de elementos NO coincide entre '{nombre_fc_orig}' y '{nombre_fc_new}'.\n")

if __name__ == "__main__":
# Solicita al usuario la ruta de la geodatabase de destino
gdb_destino = input("Ingrese la ruta de la geodatabase de destino: ")

# Ruta de la tabla cod_catastrales
tabla_cod_catastrales = f"{gdb_destino}\\cod_catastrales"

# Realizar join y exportar para rustico
realizar_join_y_exportar(gdb_destino, "rA_", "r_", "rustico", tabla_cod_catastrales)

# Realizar join y exportar para urbano
realizar_join_y_exportar(gdb_destino, "uA_", "u_", "urbano", tabla_cod_catastrales)

# Verificar elementos rústicos
verificar_elementos(gdb_destino, "rA_", "r_", "rustico")

# Verificar elementos para urbano
verificar_elementos(gdb_destino, "uA_", "u_", "urbano")

alguien sabe como resolverlo?

Gracias

Re: Making a join between a table and many Feature classes and being able to export them

HaydenWelch — Fri, 05 Jul 2024 18:02:18 GMT

Here's an implementation of a FeatureJoiner class that should help:

import arcpy import os from typing import Self class FeatureJoiner(): def __init__(self, path: os.PathLike): self.path = path self.describe = arcpy.Describe(path) self.name = self.describe.name self.fields = self.describe.fields self.field_names = [field.name for field in self.fields] self._join_field = None @property def join_field(self): return self._join_field @join_field.setter def join_field(self, field_name: str): if field_name not in self.field_names: raise ValueError(f"The field '{field_name}' does not exist in the feature class") self._join_field = field_name @join_field.deleter def join_field(self): self._join_field = None def create_join_features(self, other: Self, out_table: os.PathLike) -> object: """Create a table with the joined features. Parameters: other: FeatureJoiner The other FeatureJoiner object to join with. out_table: os.PathLike The path to the output table. Returns: object["FeatureClass"] The result of the join. """ join = self + other new_features = arcpy.management.CopyFeatures(join, out_table)[0] return new_features def __str__(self) -> str: return f"{self.name}:\n\tElements: {len(self)}\n\tJoin Field: {self.join_field}" def __eq__(self, other: Self) -> bool: return len(self) == len(other) def __len__(self) -> int: return int(arcpy.management.GetCount(self.path)[0]) def __add__(self, other: Self) -> arcpy.Result: # Make sure a join is possible if not self.join_field: raise ValueError(f"The join field has not been set for {self.name}!") if not isinstance(other, FeatureJoiner): raise TypeError(f"Unsupported operand type(s) for +: 'FeatureClass' and '{type(other)}'") if not other.join_field: raise ValueError(f"The join field has not been set for {other.name}!") if self != other: raise ValueError(f"The number of elements in {self.name} and {other.name} do not match!") # Perform the join and return the result layer = arcpy.management.AddJoin(self.path, self.join_field, other.path, other.join_field, "KEEP_ALL")[0] return layer if __name__ == "__main__": # Get database path database = input("Enter the path to the geodatabase: ") # Set workspace arcpy.env.workspace = database # Join field JOIN_FIELD = "Codigo_Municipal_Catastral" # Set join table path tabla_cod_catastrales = FeatureJoiner(os.path.join(database, "cod_catastrales")) tabla_cod_catastrales.join_field = JOIN_FIELD # Suffixes suffixes = ["_r", "_u"] # Prefixes prefixes = ["rA_", "uA_"] # Datasets datasets = ["rustico", "urban"] for suffix, prefix, dataset in zip(suffixes, prefixes, datasets): for fc in arcpy.ListFeatureClasses(wildcard=f"{suffix}*", feature_dataset=dataset): feature = FeatureJoiner(os.path.join(database, dataset, fc)) feature.join_field = JOIN_FIELD out_features = os.path.join(database, f"{prefix}{fc[len(suffix):]}") try: join_features = feature.create_join_features(tabla_cod_catastrales, out_features) except Exception as e: print(f"Error creating {os.path.basename(out_features)}: {e}") print(f"Created {os.path.basename(out_features)}") # Do something with the output features (join_features) here like adding them # to a map using arcpy.mp.<Map>.AddDataFromPath() or arcpy.management.MakeFeatureLayer()

topic Making a join between a table and many Feature classes and being able to export them in Python Questions

Making a join between a table and many Feature classes and being able to export them

Re: Making a join between a table and many Feature classes and being able to export them