[GIS] Setting list of fields to field mapping of spatial join using ArcPy

arcpyfield-mappingspatial-join

I try to code spatial join tool and delete some fields in the result. to delete the fields i list the fields of source layer and the result layer then use the list of differences in the two list and usedelete field management tool.it's working but not good solution.If i can set the Spatial Join field mapping to remain the source layer fields and only the "Distance_To_Next" field of the join layer, i get rid of some codes and iterates but don't know how to set the field mapping in the code.

Scripting spatial join in ArcPy to set field attribute in field mapping object? is the only result that i could find in the stack but not my answer.

import arcpy
arcpy.SpatialJoin_analysis("Point1", "point2","JoinResult","JOIN_ONE_TO_ONE","#","#","INTERSECT")
listfields1 = [fraft.name for fraft in arcpy.ListFields("Point1")]
listfields2 = [fraftv.name for fraftv in arcpy.ListFields("JoinResult")]
diff_fields = [i for i in listfields2 if not i in listfields1]
for field in diff_fields:
    if field != "Distance_To_Next":
        arcpy.DeleteField_management("JoinResult",field)

Best Answer

To manipulate the fields, their order, names, and other properties it is necessary to use the arcpy.FieldMappings() class. It is not very easy to get to know them and start using, so I've added extra comments to help you understand the workflow.

In this example, I am doing spatial join transferring just two fields from counties to cities.

import arcpy

cities = r'C:\Program Files (x86)\ArcGIS\Desktop10.4\TemplateData\TemplateData.gdb\USA\cities'
counties = r'C:\Program Files (x86)\ArcGIS\Desktop10.4\TemplateData\TemplateData.gdb\USA\counties'

#constructing an instance of <FieldMappings object>
fms = arcpy.FieldMappings()

#loading all field objects from counties into the <FieldMappings object>
fms.addTable(counties)

fields_sequence = ['CNTY_FIPS','CNTY_NAME']
#remove fieldmaps for those fields that are not needed in the output joined fc
fields_to_delete = [f.name for f in fms.fields if f.name not in fields_sequence]
for field in fields_to_delete:
    fms.removeFieldMap(fms.findFieldMapIndex(field))

#currently field mappings from counties have just two fields we have left
#[f.name for f in fms.fields] [u'NAME', u'CNTY_FIPS']

#now need to create a new fms and loat all fields from cities fc
#compiling output fms - all fields from cities
fms_out = arcpy.FieldMappings()
fms_out.addTable(cities)

# we need to add those two fields from counties
for field in fields_sequence:
    mapping_index = fms.findFieldMapIndex(field)
    field_map = fms.fieldMappings[mapping_index]
    fms_out.addFieldMap(field_map)

#[f.name for f in fms_out.fields] [all cities fields ] + [u'CNTY_FIPS',u'CNTY_NAME']

arcpy.SpatialJoin_analysis(target_features=cities, join_features=counties,
                          out_feature_class=r'C:\ArcGIS\scratch.gdb\resJoin',
                          join_operation='JOIN_ONE_TO_ONE',join_type='KEEP_ALL',
                          field_mapping=fms_out,match_option='WITHIN',
                          search_radius=None,distance_field_name=None)

Related Solutions

ArcGIS Field Mapping – How to Perform Field Mapping in ArcGIS 10 Using ArcPy

I think you need to actually use FieldMappings.replaceFieldMap to get it to persist. Example from help topic Mapping input fields to output fields:

# First get the TRACT2000 fieldmap. Then add the TRACTCODE field
#   from Blocks2 as an input field. Then replace the fieldmap within
#   the fieldmappings object.
#
fieldmap = fieldmappings.getFieldMap(fieldmappings.findFieldMapIndex("TRACT2000"))
fieldmap.addInputField(fc2, "TRACTCODE")
fieldmappings.replaceFieldMap(fieldmappings.findFieldMapIndex("TRACT2000"), fieldmap)

Another thought is that when testing field maps, I like to use a script tool and custom script tool behavior so I can visually inspect the field map instead of trying to decode the crazy long strings they produce.

Example ToolValidator class I used to conclude that yes, replaceFieldMap is required for it to be persisted in the parameter value:

class ToolValidator:
  """Class for validating a tool's parameter values and controlling
  the behavior of the tool's dialog."""

  def __init__(self):
    """Setup arcpy and the list of tool parameters."""
    import arcpy
    self.params = arcpy.GetParameterInfo()

  def initializeParameters(self):
    """Refine the properties of a tool's parameters.  This method is
    called when the tool is opened."""
    return

  def updateParameters(self):
    """Modify the values and properties of parameters before internal
    validation is performed.  This method is called whenever a parmater
    has been changed."""
    if (not self.params[0].hasBeenValidated
    or not self.params[1].hasBeenValidated):
        targetFeatures = self.params[0].value
        joinFeatures = self.params[1].value
        fieldMappings = arcpy.FieldMappings()
        if targetFeatures:
            fieldMappings.addTable(targetFeatures)
            if joinFeatures:
                fieldMappings.addTable(joinFeatures)
                idx = fieldMappings.findFieldMapIndex("PRIORITY")
                fieldMap = fieldMappings.getFieldMap(idx)
                fieldMap.mergeRule = 'Sum'
                fieldMappings.replaceFieldMap(idx, fieldMap) # if this line is commented out, the merge rule reverts to 'First'
        self.params[3].value = fieldMappings.exportToString()
    return

  def updateMessages(self):
    """Modify the messages created by internal validation for each tool
    parameter.  This method is called after internal validation."""
    return

[GIS] Spatial Join Field Mapping in ArcPy

Field mappings are kind of cumbersome in ArcGIS. First you create a fieldmappings object, then create fieldmap, then add input fields and define output fields. Also, you can add the entire table to the mapping like:

    myMapping = arcpy.FieldMappings()
    myMapping.addTable(path_to_the_table)
    arcpy.Append_management(fc, fc_out, "NO_TEST", myMapping)

I found the following example that I used some time ago when building custom mappings:

in_file1 = 'data.gdb/Trees'
in_file2 = 'Plants.shp'
output_file = 'data.gdb/Vegetation'

# Create the required FieldMap and FieldMappings objects.
fm_type = arcpy.FieldMap()
fm_diam = arcpy.FieldMap()
fms = arcpy.FieldMappings()

# Get the field names of vegetation type and diameter for both original files.
tree_type = "Tree_Type"
plant_type = "Plant_Type"

tree_diam = "Tree_Diameter"
plant_diam = "Diameter"

# Add fields to their corresponding FieldMap objects.
fm_type.addInputField(in_file1, tree_type)
fm_type.addInputField(in_file2, plant_type)

fm_diam.addInputField(in_file1, tree_diam)
fm_diam.addInputField(in_file2, plant_diam)

# Set the output field properties for both FieldMap objects.
type_name = fm_type.outputField
type_name.name = 'Veg_Type'
fm_type.outputField = type_name

diam_name = fm_diam.outputField
diam_name.name = 'Veg_Diam'
fm_diam.outputField = diam_name

# Add the FieldMap objects to the FieldMappings object.
fms.addFieldMap(fm_type)
fms.addFieldMap(fm_diam)

# Merge the two feature classes.
arcpy.Merge_management([in_file1, in_file2], output_file, fms)

Best Answer

Related Solutions

ArcGIS Field Mapping – How to Perform Field Mapping in ArcGIS 10 Using ArcPy

[GIS] Spatial Join Field Mapping in ArcPy

Related Question