【Arcpy】批量合并重叠拓扑

「爱情、让人受尽委屈。」 2022-09-02 13:55 289阅读 0赞

# 需求 #

图形存在大量重叠问题，需要对重叠做合并处理，有特定的对比规则（即判断应合并到哪个要素），人工处理耗时长，对因合并要素产生的图形变化而造成的误差不敏感。

# 思路 #

1.  将重叠批量生成要素；
2.  按照图形属性 or 几何特征判断各个重叠归属于相邻要素（可能是多个）中的哪一个；
3.  将重叠要素合并到指定的要素中；
4.  删除重叠要素。

# 实现 #

基于arcpy完成以上功能开发，主要运用到了按照空间关系搜索（`SelectLayerByLocation_management`）、按照属性搜索（`SelectLayerByAttribute_management`）、联合（`Union`）等功能。

1.  选出属性为空的要素，说明为重叠要素；
2.  选出与重叠相邻的要素（共享线段`SHARE_A_LINE_SEGMENT_WITH` 但是不完全一致`ARE_IDENTICAL_TO`，此外该要素也不能是重叠要素，注意不能是`touch`，因为可能仅仅只是`touch`于一个点），说明为产生该重叠的两个要素；
3.  判断这两个要素合并优先次序；
4.  重叠要素`Union`到合并次序高的要素，然后通过对`Shape@`属性赋值实现保存结果。

# mergeOverlap.py
    
    # coding: utf-8
    import arcpy
    
    def chooseOID(attr_list):
        if len(attr_list) < 2:
            return None
        else:
            oid_list = [attr[0] for attr in attr_list]
            sjly_list = [attr[1] for attr in attr_list]
            nf_list = [attr[2] for attr in attr_list]
            ydxz_list = [attr[3] for attr in attr_list]
            shape_area_list = [attr[4] for attr in attr_list]
            
            # 数据来源
            if sjly_list.count(u"供地数据（金土工程补充）") == (len(sjly_list) - 1):
                idx_list = [i for i,x in enumerate(sjly_list) if (x is not None and x.strip()!="" and x != u"供地数据（金土工程补充）")]
                if len(idx_list) == 1:
                    idx = idx_list[0]
                    return oid_list[idx]
            
            # 时间
            if nf_list.count(None) == 0:
                nf_len_list = [len(x.strip()) for x in nf_list]
                if nf_len_list.count("4") == len(nf_list):
                    nf_list = [int(x) for x in nf_list]
                    idx = nf_list.index(max(nf_list))
                    return oid_list[idx]
    
            # 性质
            if ydxz_list.count(u"经营性") == (len(ydxz_list) - 1):
                idx_list = [i for i,x in enumerate(ydxz_list) if (x is not None and x.strip()!="" and x == u"公益性")]
                if len(idx_list) == 1:
                    idx = idx_list[0]
                    return oid_list[idx]
    
            # 面积
            idx = shape_area_list.index(max(shape_area_list))
            return oid_list[idx]
    
    
    
    
    def mergeOverlap(refer_fc_path, update_fc_path):
        arcpy.MakeFeatureLayer_management(refer_fc_path, "LYR")
        
        refer_search_fields = ("SHAPE@", "OBJECTID", "SJLY", "Z_NF", "Z_GYJY", "SHAPE_AREA")
        refer_where_clause = "SJLY IS NULL"
    
        # 遍历所有重叠图形
        i = 0
        with arcpy.da.SearchCursor(refer_fc_path, refer_search_fields, refer_where_clause) as refer_search_cursor:
            for refer_search_row in refer_search_cursor:
                update_oid = None
                overlap_oid = None
                try:
                    refer_overlap_geometry = refer_search_row[0]
                    overlap_oid = refer_search_row[1]
    
                    # arcpy.SelectLayerByLocation_management("LYR", "BOUNDARY_TOUCHES", refer_overlap_geometry)
                    arcpy.SelectLayerByLocation_management("LYR", "SHARE_A_LINE_SEGMENT_WITH", refer_overlap_geometry)
                    arcpy.SelectLayerByLocation_management("LYR", "ARE_IDENTICAL_TO", refer_overlap_geometry, selection_type = "REMOVE_FROM_SELECTION")
                    arcpy.SelectLayerByAttribute_management("LYR", "SUBSET_SELECTION", "SJLY IS NOT NULL")
                    
                    # 找到重叠图形相邻的多个图形
                    attr_list = []
                    with arcpy.da.SearchCursor("LYR", refer_search_fields) as refer_search_cursor2:
                        for refer_search_row2 in refer_search_cursor2:
                            oid = refer_search_row2[1]
                            sjly = refer_search_row2[2]
                            nf = refer_search_row2[3]
                            gyjy = refer_search_row2[4]
                            shape_area = refer_search_row2[5]
                            attr_list.append([oid, sjly, nf, gyjy, shape_area])            
    
                    # # 得到需要更新的oid
                    update_oid = chooseOID(attr_list)
                    if update_oid is not None:
                        # 合并
                        update_where_clause = "OBJECTID=" + str(update_oid)
                        with arcpy.da.UpdateCursor(update_fc_path, refer_search_fields, update_where_clause) as update_cursor:
                            for update_row in update_cursor:
                                update_geometry = update_row[0]
                                new_geometry = update_geometry.union(refer_overlap_geometry)
                                update_row[0] = new_geometry
                                update_cursor.updateRow(update_row)
                                break
    
                        # 删除已合并
                        update_where_clause2 = "OBJECTID=" + str(overlap_oid)
                        with arcpy.da.UpdateCursor(update_fc_path, refer_search_fields, update_where_clause2) as update_cursor:
                            for update_row in update_cursor:
                                update_cursor.deleteRow()
    
                        print i, update_oid, overlap_oid, len(attr_list)
                        i+=1
                except:
                    print "___________>", update_oid, overlap_oid
    
                    
    
    if __name__ == "__main__":
        refer_fc_path = "C:\Users\may\Desktop\\20210803-数据细化重叠图斑批量处理\C_重叠修正结果\T20210803供地数据批处理.gdb\\refer0"
        update_fc_path = "C:\Users\may\Desktop\\20210803-数据细化重叠图斑批量处理\C_重叠修正结果\T20210803供地数据批处理.gdb\\update0"
        mergeOverlap(refer_fc_path, update_fc_path)

从多个字段提取年份信息：

# extractYear.py
    
    import re
    
    def extractYear(pzsh, qdrq, htbh):
        try:
            pattern_pzsh = re.compile("([^\d])(19\d{2}|20\d{2})([^\d])")
            pattern_qdrq = re.compile("([^\d])(19\d{2}|20\d{2})([^\d])")
            pattern_htbh = re.compile("([^\d])(19\d{2}|20\d{2})([^\d])")
            if pzsh is not None and pattern_pzsh.search(pzsh):
                result = pattern_pzsh.search(pzsh).group(2)
                return result
            elif qdrq is not None and pattern_qdrq.search(qdrq):
                result = pattern_qdrq.search(qdrq).group(2)
                return result
            elif htbh is not None and pattern_htbh.search(htbh):
                result = pattern_htbh.search(htbh).group(2)
                return result
            else:
                return ""
        except:
            return "xxx"
    
    extractYear( !JSYDPZSH! , !QDSJ! , !HTBH! )
    
    
    
    import re
    
    def extractYear(pfwh):
        try:
            pattern = re.compile("([^\d])(19\d{2}|20\d{2})([^\d])(\d{1,4})")
            if pfwh is not None and pattern.search(pfwh):
                year = pattern.search(pfwh).group(2)
                index = pattern.search(pfwh).group(4)
                index = index.zfill(5)
                return year+index
        except:
            return "xxx"