def updateDomains(domainsFolder, targetGDB): try: arcpy.AddMessage("Starting: UpdateDomains") # Update all coded (list) domains path = os.path.normpath( os.path.join(domainsFolder, "Coded_Domain_*.csv")) for fname in glob.glob(path): # Find the domain's name and description and then add it to the gdb domainName, domainDescription = findNameAndDescription( fname, "Coded_Domain_") arcpy.AddMessage("Updating domain " + domainName + "...") arcpy.TableToDomain_management(fname, "Value", "Name", targetGDB, domainName, domainDescription, "REPLACE") # Update all range domains path = os.path.normpath( os.path.join(domainsFolder, "Range_Domain_*.csv")) for fname in glob.glob(path): # Find the domain's name and description and then add it to the gdb domainName, domainDescription = findNameAndDescription( fname, "Range_Domain_") arcpy.AddMessage("Updating domain " + domainName + "...") # Set the range domain's min and max values with open(fname, 'r') as csvFile: reader = csv.reader(csvFile, dialect='excel') # Skip the header, use the second line header = next(reader) line = next(reader) arcpy.CreateDomain_management(targetGDB, domainName, domainDescription, Utility.fieldTypeLookup(line[0]), "RANGE") arcpy.SetValueForRangeDomain_management( targetGDB, domainName, int(line[1]), int(line[2])) except Exception as err: arcpy.AddError( traceback.format_exception_only(type(err), err)[0].rstrip()) else: arcpy.AddMessage("Success! - Completed: UpdateDomains") finally: arcpy.AddMessage("Exiting: UpdateDomains")
def add_additive_specification_range_domain_to_gdb(in_gdb, in_features, fields, domain_name, field_type="DOUBLE", range_min=0, range_max=25): """This function will add additive shared-row specification domains for categorical fields based on a CSV. Uses Pandas. :param - in_gdb - input geodatabase to add domains to :param - in_features - optional input that is used to assign domains to feature class is chosen. :param - domain_name - name of new range domain :param - field_type - field type used by domains :param - fields - fields to assign domains too :param - range_min - the minimum value allowed by the range domain :param - range_max - the maximum value allowed by the range domain """ try: domain_description = str(domain_name) + "_Range_Domain" try: srl.arc_print("Adding range domain for numeric values...") arcpy.CreateDomain_management(in_gdb, domain_name, domain_description, field_type, "RANGE") except: arcpy.AddWarning("Could not create domain. Either it already exists or some other error...") srl.arc_print("Set min and max values of domains...") arcpy.SetValueForRangeDomain_management(in_gdb, domain_name, range_min, range_max) srl.arc_print("Attempting to assign numeric fields ...") for field in fields: try: if len(arcpy.ListFields(in_features, field)) > 0: arcpy.AssignDomainToField_management(in_features, field, domain_name) except: arcpy.AddWarning("Could not assign domain to field {0}...".format(field)) except Exception as e: srl.arc_print("Tool Script Error!") import traceback, sys tb = sys.exc_info()[2] srl.arc_print("An error occurred on line %i" % tb.tb_lineno) arcpy.AddError("The error occurred on line {0}...".format(tb.tb_lineno))
def check_and_create_domains(geodatabase): """ Checks if the domains already exist, if they do then it checks the values and ranges If the domains do not exist, they are created :param geodatabase: (string) the path to the geodatabase to check :return: """ domains = arcpy.da.ListDomains(geodatabase) domain_names = [domain.name for domain in domains] if 'ESRI_FIX_TYPE_DOMAIN' in domain_names: for domain in domains: if domain.name == 'ESRI_FIX_TYPE_DOMAIN': # check if cvs 0,1,2,4,5 are in the codedValues values = [cv for cv in domain.codedValues] if not set(set([0, 1, 2, 4, 5])).issubset(values): arcpy.AddError( "ESRI_FIX_TYPE_DOMAIN is missing a coded value pair.") return else: # Add the domain and values arcpy.AddMessage( 'Adding ESRI_FIX_TYPE_DOMAIN domain to parent geodatabase...') arcpy.CreateDomain_management(in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", domain_description="Fix Type", field_type="SHORT", domain_type="CODED", split_policy="DEFAULT", merge_policy="DEFAULT") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", code="0", code_description="Fix not valid") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", code="1", code_description="GPS") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", code="2", code_description="Differential GPS") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", code="4", code_description="RTK Fixed") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_FIX_TYPE_DOMAIN", code="5", code_description="RTK Float") # Check if 'NumSats" is a domain, if so check the range if 'ESRI_NUM_SATS_DOMAIN' in domain_names: if domain.name == "ESRI_NUM_SATS_DOMAIN": if domain.range[0] != 0 or domain.range[1] != 99: arcpy.AddError("ESRI_NUM_SATS_DOMAIN domain has invalid range") return else: # Add the domain and set the range arcpy.AddMessage("Adding ESRI_NUM_SATS_DOMAIN to parent database...") arcpy.CreateDomain_management( in_workspace=geodatabase, domain_name="ESRI_NUM_SATS_DOMAIN", domain_description="Number of Satellites", field_type="SHORT", domain_type="RANGE", split_policy="DEFAULT", merge_policy="DEFAULT") arcpy.SetValueForRangeDomain_management(geodatabase, "ESRI_NUM_SATS_DOMAIN", 0, 99) if 'ESRI_POSITIONSOURCETYPE_DOMAIN' in domain_names: for domain in domains: if domain.name == 'ESRI_POSITIONSOURCETYPE_DOMAIN': # check if cvs 0,1,2,3,4 are in the codedValues values = [cv for cv in domain.codedValues] if not set(set([0, 1, 2, 3, 4])).issubset(values): arcpy.AddError( "ESRI_POSITIONSOURCETYPE_DOMAIN is missing a coded value pair." ) return else: # Add the domain and values arcpy.AddMessage( 'Adding ESRI_POSITIONSOURCETYPE_DOMAIN domain to parent geodatabase...' ) arcpy.CreateDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", domain_description="Position Source Type", field_type="SHORT", domain_type="CODED", split_policy="DEFAULT", merge_policy="DEFAULT") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", code="0", code_description="Unknown") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", code="1", code_description="User defined") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", code="2", code_description="Integrated (System) Location Provider") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", code="3", code_description="External GNSS Receiver") arcpy.AddCodedValueToDomain_management( in_workspace=geodatabase, domain_name="ESRI_POSITIONSOURCETYPE_DOMAIN", code="4", code_description="Network Location Provider")
arcpy.CreateFileGDB_management(out_folder, dbName) logger.logGPMsg() print "creating coded value domains" for d in domains: print d arcpy.TableToDomain_management(domainsXLS + "\\" + d + "$", "CODE", "CODE", gdb, "roadkill_" + d, "roadkill_" + d) logger.logGPMsg() print "creating xyphoid range domain" arcpy.CreateDomain_management(gdb, xyphoidDomainName, xyphoidDomainName, "SHORT", "RANGE") logger.logGPMsg() arcpy.SetValueForRangeDomain_management(gdb, xyphoidDomainName, xyphoidMin, xyphoidMax) logger.logGPMsg() print "creating Reports fc" srPath = os.path.join( arcpy.GetInstallInfo()["InstallDir"], r"Coordinate Systems\Projected Coordinate Systems\UTM\NAD 1983\NAD 1983 UTM Zone 12N.prj" ) spatial_reference = arcpy.SpatialReference(srPath) arcpy.CreateFeatureclass_management(gdb, reports, "POINT", None, None, None, spatial_reference) logger.logGPMsg() print "adding fields" for f in fields: print f
def create_fc_fields_with_domains(fgdb_path): """ :param fgdb_path: file path to the file geodatabase :type fgdb_path: basestring """ arcpy.env.workspace = fgdb_path arcpy.env.overwriteOutput = True # --------------------------------------------------------------- # define domains # # pattern: # # for coded domains # create a domain object _in the GDB_ (not as a Python object) # create a dictionary of domain code:description pairs # load the dictionary into the domain # use the domain when creating a feature class or use # arcpy.AssignDomainToField_management() # # for range domains # create a domain object _in the GDB_ (not as a Python object) # set SetValueForRangeDomain_management # use the domain when creating a feature class or use # arcpy.AssignDomainToField_management() # # -------------------------------------------------------------- log.info("Creating feature class") fc_name = "GDA94_fields_with_domains_polyline" fc_path = os.path.join(fgdb_path, fc_name) arcpy.CreateFeatureclass_management( out_path=fgdb_path, out_name=fc_name, geometry_type="POLYLINE", spatial_reference=arcpy.SpatialReference(4283)) # GDA94 lat/long) log.info("Creating domains") # -------------------------------------- domain_name = "text_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded TEXT domain", field_type="TEXT", domain_type="CODED") text_field_coded_domain_dict = {"R": "Red", "G": "Green", "B": "Blue"} for code in text_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=text_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="text_field_with_coded_domain", field_type="TEXT", field_length=50, field_alias="has a TEXT coded domain", field_domain="text_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "float_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded FLOAT domain", field_type="FLOAT", domain_type="CODED") float_field_coded_domain_dict = { 1.1: "one decimal place", 1.01: "two decimal places", 1.001: "three decimal places" } for code in float_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=float_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="float_field_with_coded_domain", field_type="FLOAT", field_alias="has a FLOAT coded domain", field_domain="float_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "float_field_range_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a FLOAT range domain", field_type="FLOAT", domain_type="RANGE") arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path, domain_name=domain_name, min_value=1.1, max_value=2.2) arcpy.AddField_management(in_table=fc_path, field_name="float_field_with_range_domain", field_type="FLOAT", field_alias="has a FLOAT range domain", field_domain="float_field_range_domain") # ----------------------------------------------------------------------------------- domain_name = "double_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded DOUBLE domain", field_type="DOUBLE", domain_type="CODED") double_field_coded_domain_dict = { 2.2: "one decimal place", 2.00000000001: "10 decimal places", 2.00000000000000000002: "20 decimal places" } for code in double_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=double_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="double_field_with_coded_domain", field_type="DOUBLE", field_alias="has a DOUBLE coded domain", field_domain="double_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "double_field_range_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a DOUBLE range domain", field_type="DOUBLE", domain_type="RANGE") arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path, domain_name=domain_name, min_value=1.00000000000000000001, max_value=20000000000000000000.2) arcpy.AddField_management(in_table=fc_path, field_name="double_field_with_range_domain", field_type="DOUBLE", field_alias="has a DOUBLE range domain", field_domain="double_field_range_domain") # ----------------------------------------------------------------------------------- domain_name = "short_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded SHORT domain", field_type="SHORT", domain_type="CODED") short_field_coded_domain_dict = { 101: "one O one", 102: "one O two", 103: "one O three" } for code in short_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=short_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="short_field_with_coded_domain", field_type="SHORT", field_alias="has a SHORT coded domain", field_domain="short_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "short_field_range_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a SHORT range domain", field_type="SHORT", domain_type="RANGE") arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path, domain_name=domain_name, min_value=1000, max_value=2000) arcpy.AddField_management(in_table=fc_path, field_name="short_field_with_range_domain", field_type="SHORT", field_alias="has a SHORT range domain", field_domain="short_field_range_domain") # ----------------------------------------------------------------------------------- domain_name = "long_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded LONG domain", field_type="LONG", domain_type="CODED") long_field_coded_domain_dict = { 40000: "forty thousand", 400000: "four hundred thousand", 4000000: "four million" } for code in long_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=long_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="long_field_with_coded_domain", field_type="LONG", field_alias="has a LONG coded domain", field_domain="long_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "long_field_range_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a LONG range domain", field_type="LONG", domain_type="RANGE") arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path, domain_name=domain_name, min_value=12000000, max_value=120000000) arcpy.AddField_management(in_table=fc_path, field_name="long_field_with_range_domain", field_type="LONG", field_alias="has a LONG range domain", field_domain="long_field_range_domain") # ----------------------------------------------------------------------------------- domain_name = "date_field_coded_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a coded DATE domain", field_type="DATE", domain_type="CODED") date_field_coded_domain_dict = { "01-02-1972": "Mic's Birthday", "09-08-1969": "Donna's Birthday", "22-04-2002": "Annie's Birthday" } for code in date_field_coded_domain_dict: arcpy.AddCodedValueToDomain_management( in_workspace=fgdb_path, domain_name=domain_name, code=code, code_description=date_field_coded_domain_dict[code]) arcpy.AddField_management(in_table=fc_path, field_name="date_field_with_coded_domain", field_type="DATE", field_alias="has a DATE coded domain", field_domain="date_field_coded_domain") # ----------------------------------------------------------------------------------- domain_name = "date_field_range_domain" arcpy.CreateDomain_management( in_workspace=fgdb_path, domain_name=domain_name, domain_description="uses a DATE range domain", field_type="DATE", domain_type="RANGE") arcpy.SetValueForRangeDomain_management(in_workspace=fgdb_path, domain_name=domain_name, min_value="01-01-1972", max_value="22-04-2002") arcpy.AddField_management(in_table=fc_path, field_name="date_field_with_range_domain", field_type="DATE", field_alias="has a DATE range domain", field_domain="date_field_range_domain")
def createUN(jsonFile, outGDB): cfgStr = open(jsonFile, 'r', encoding='gbk').read() unObj = json.loads(cfgStr) unName = unObj["unName"] # 创建un和结构网络 arcpy.env.preserveGlobalIds = True arcpy.env.overwriteOutput = True arcpy.CreateFileGDB_management(os.path.dirname(outGDB), os.path.basename(outGDB)) arcpy.pt.StageUtilityNetwork(outGDB, unObj["territoryFeaCls"], unObj["feaDS"], unName) # Tips:尽量使用相对路径,如有工具不支持再改用绝对路径 arcpy.env.workspace = os.path.join(outGDB, unObj["feaDS"]) # 导入fieldDomains,domain是面向GDB级的物理设置 for domain in unObj["fieldDomains"]: dName = domain["name"] if domain.get("dtype") == "RANGE": arcpy.CreateDomain_management(outGDB, dName, domain.get("desc", dName), domain.get("ftype", "SHORT"), "RANGE") arcpy.SetValueForRangeDomain_management(outGDB, dName, domain['min'], domain['max']) continue table = arcpy.management.CreateTable('in_memory', dName)[0] # ?[0] arcpy.AddField_management(table, 'code', domain.get("ftype", "SHORT")) arcpy.AddField_management(table, 'name', 'TEXT', field_length=254) with arcpy.da.InsertCursor(table, ('code', 'name')) as cur: for v in domain["values"]: cur.insertRow((v["code"], v["name"])) arcpy.TableToDomain_management(table, 'code', 'name', outGDB, dName, domain.get("desc", dName), update_option='REPLACE') arcpy.Delete_management(table) # 创建除了structure以外的域网络 for dnObj in unObj["domainNetworks"]: if dnObj["name"].lower() != "structure": arcpy.AddDomainNetwork_un(unName, dnObj["name"], dnObj["tierDef"], dnObj["controllerType"], dnObj.get("alias")) # 添加TerminalConfiguration,categories,netAttributes,这些是面向整个UN级的逻辑设置 # Tips:需要先创建至少一个域网络,才能添加TerminalConfiguration terminalConfigs = unObj.get("terminalConfigs") if terminalConfigs: for terminalCfg in terminalConfigs: if terminalCfg["dir"] == "DIRECTIONAL": arcpy.AddTerminalConfiguration_un( unName, terminalCfg["name"], "DIRECTIONAL", terminals_directional=terminalCfg["terminals"], valid_paths=terminalCfg["paths"], default_path=terminalCfg.get("default")) else: arcpy.AddTerminalConfiguration_un( unName, terminalCfg["name"], "BIDIRECTIONAL", terminals_bidirectional=terminalCfg["terminals"], valid_paths=terminalCfg["paths"], default_path=terminalCfg.get("default")) # TODO: 网络分组与分层的区别? categories = unObj.get("categories") if categories: ## 为什么加这种判断 for category in categories: arcpy.AddNetworkCategory_un(unName, category) # TODO:网络属性的可选设置有什么作用? netAttributes = unObj.get("netAttributes") if netAttributes: for attrib in netAttributes: arcpy.AddNetworkAttribute_un(unName, attrib["name"], attrib["type"], attrib.get("inline"), attrib.get("apportionable"), attrib.get("domain"), attrib.get("overridable"), attrib.get("nullable"), attrib.get("substitution"), attrib.get("attrToSubstitution")) # 添加子类,创建新字段,指定属性域,指定网络属性,这些是面向Table级的物理设置 for dnObj in unObj["domainNetworks"]: # 子类已经自动设置为ASSETGROUP字段,添加自定义值 subtypes = dnObj.get("subtypes") if subtypes: for subtype in subtypes: for v in subtype["values"]: arcpy.AddSubtype_management(subtype["feaCls"], v["code"], v["name"]) if subtype.get("default"): arcpy.SetDefaultSubtype_management(subtype["feaCls"], subtype.get("default")) # 添加自定义字段 newFields = dnObj.get("newFields") if newFields: for field in newFields: length = field.get( "length") if field["type"].upper() == "TEXT" else None arcpy.AddField_management(field["feaCls"], field["name"], field["type"], field_length=length, field_alias=field.get("alias")) # 为字段指定属性域 fDomains = dnObj.get("fieldDomains") if fDomains: for fd in fDomains: arcpy.AssignDomainToField_management(fd["feaCls"], fd["fieldName"], fd["domainName"], fd.get("subtypeCodes")) if fd.get("default"): arcpy.AssignDefaultToField_management( fd["feaCls"], fd["fieldName"], fd["default"], fd.get("subtypeCodes")) # 为字段指定网络属性 netAttributes = dnObj.get("netAttributes") if netAttributes: for attribute in netAttributes: for field in attribute["fields"]: fc, fName = field.split("/") fObj = arcpy.ListFields(fc, fName) if fObj: arcpy.SetNetworkAttribute_un(unName, attribute["name"], dnObj["name"], fc, fName) # 为资产指定多项配置:端子配置、分组、边连通性、角色,这些是面向资产级的逻辑设置 with open(unObj.get("assetsCSV", "not exist"), 'r', encoding='gbk') as fp: reader = csv.reader(fp) # 读取列为列表 header = next( reader ) # ['domainNet', 'feaCls', 'assetName', 'categories', 'terminalCfg', 'edgeConnectivity', 'roleType', 'deletionType', 'viewScale', 'splitType'] assetCfg = namedtuple('assetCfg', header) for row in reader: row = assetCfg(*row) asset = row.assetName.split('/') if row.terminalCfg: arcpy.SetTerminalConfiguration_un(unName, row.domainNet, row.feaCls, *asset, row.terminalCfg) if row.categories: arcpy.SetNetworkCategory_un(unName, row.domainNet, row.feaCls, *asset, row.categories) if row.edgeConnectivity: # 边联通非空 arcpy.SetEdgeConnectivity_un(unName, row.domainNet, row.feaCls, *asset, row.edgeConnectivity) if row.roleType: arcpy.SetAssociationRole_un(unName, row.domainNet, row.feaCls, *asset, row.roleType, row.deletionType, row.viewScale, row.splitType) # 创建tier,并设置子网定义,这些是面向子网级的逻辑设置 # TODO: subnetwork_field_name有什么作用?subnetDef还有很多可选设置 for dnObj in unObj["domainNetworks"]: dnName = dnObj["name"] if dnName.lower() != "structure": # tierGroups tierGroups = dnObj.get("tierGroups") if tierGroups and dnObj["tierDef"] == "HIERARCHICAL": for groupName in tierGroups: arcpy.AddTierGroup_un(unName, dnName, groupName) tiers = dnObj.get("tiers") if tiers: for tier in tiers: if dnObj["tierDef"] == "HIERARCHICAL": arcpy.AddTier_un( unName, dnName, tier["name"], tier["rank"], topology_type="MESH", tier_group_name=tier.get("groupName"), subnetwork_field_name=tier["subnetField"]) else: arcpy.AddTier_un(unName, dnName, tier["name"], tier["rank"], topology_type=tier["topo"]) arcpy.SetSubnetworkDefinition_un( unName, dnName, tier["name"], tier["disjoint"], tier["devices"], tier["controllers"], tier.get("lines"), tier.get("aggregated"), tier.get("diagrams"), include_barriers=tier.get("barriers"), traversability_scope=tier.get("traverse")) # TODO: 导入rule arcpy.ImportRules_un(unName, "All", "E:/ArcGIS/unnet/rules.csv") # TODO: 导入数据 # 数据导入是基于子类的,把要素类路径写入到子类中,修改了demoUN域网络的子类型值 for dnObj in unObj["domainNetworks"]: subtypes = dnObj.get("subtypes") if subtypes: for subtype in subtypes: for v in subtype["values"]: arcpy.Append_management(subtype["path"], subtype["feaCls"], "NO_TEST", subtype=v["name"])
def testdata(request): # create a testing gdb print("Creating test geodatabase") testgdbpath = os.path.join(arcpy.env.scratchFolder, "arc_utils_test.gdb") if arcpy.Exists(testgdbpath): print("Deleting " + testgdbpath) arcpy.Delete_management(testgdbpath) arcpy.CreateFileGDB_management(arcpy.env.scratchFolder, "arc_utils_test.gdb") #add a domain for each field in testfc ftext_dom_name = "ftext_coded" fint_dom_name = "fint_range" arcpy.CreateDomain_management(in_workspace=testgdbpath, domain_name=ftext_dom_name, domain_description="text domain", field_type="TEXT", domain_type="CODED") arcpy.CreateDomain_management(in_workspace=testgdbpath, domain_name=fint_dom_name, field_type="SHORT", domain_type="RANGE") ftextDict = {"val1": "val1", "val2": "val2", "val3": "val3"} for code in ftextDict: arcpy.AddCodedValueToDomain_management(testgdbpath, ftext_dom_name, code, ftextDict[code]) arcpy.SetValueForRangeDomain_management(testgdbpath, fint_dom_name, 1, 12) print("Creating test featureclass") sr = arcpy.SpatialReference(4326) fc_name = 'test_fc' fc_fields = (('ftext', 'TEXT', None, None, 20, '', 'NULLABLE', 'NON_REQUIRED', ftext_dom_name), ('fint', 'SHORT', 0, 0, 0, '', 'NULLABLE', 'NON_REQUIRED', fint_dom_name)) fc = arcpy.CreateFeatureclass_management(testgdbpath, fc_name, "POINT", spatial_reference=sr) for fc_field in fc_fields: arcpy.AddField_management(fc, *fc_field) print("loading data") records = (("val1", 4), ("val2", 7), ("val1", 10), ("val2", 4), ("val1", 7), ("val2", 9)) with arcpy.da.InsertCursor(fc, ["ftext", "fint", "SHAPE@XY"]) as cursor: for key, val in records: lon = 122.3 + float(random.randint(-9, 9)) / 100 lat = 47.6 + float(random.randint(-9, 9)) / 100 cursor.insertRow([key, val, (lon, lat)]) # insert a couple of rows with null with arcpy.da.InsertCursor(fc, ["ftext", "fint", "SHAPE@XY"]) as cursor: cursor.insertRow(["val1", None, (122.399, 47.699)]) cursor.insertRow([None, 5, (122.399, 47.699)]) result = collections.namedtuple('testdata', 'gdb, fc') result.gdb = testgdbpath result.fc = fc def testdata_teardown(): arcpy.Delete_management(testgdbpath) request.addfinalizer(testdata_teardown) return result
try: arcpy.CreateDomain_management(gdb, domain["name"], domain["description"], domain["field_type"], domain["domain_type"]) if domain["domain_type"] == "CODED": domainValuesDict = domain["values"] # Loop through all the domain codes in the dictionary and add them to the domain for code in domainValuesDict: arcpy.AddCodedValueToDomain_management( gdb, domain["name"], code, domainValuesDict[code]) elif domain["domain_type"] == "RANGE": # Set the min and max values for a range domain arcpy.SetValueForRangeDomain_management( gdb, domain["name"], domain["min"], domain["max"]) else: print("Unknown type of domain: " + domain["domain_type"]) except Exception as domEx: print(domEx) # Create the layers layerList = layer_json["layers"] # Create dictionary object to populate with symbols and alias for the layers layerSymbolDict = {} layerAliasDict = {} for layer in layerList: print("Creating layer: " + layer["name"])
fc_path = workspace_path + '\\' + fc_name #SR Definition SRDefinition="PROJCS['WGS_1984_Web_Mercator_Auxiliary_Sphere',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator_Auxiliary_Sphere'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],PARAMETER['Auxiliary_Sphere_Type',0.0],UNIT['Meter',1.0]];-22041257.773878 -33265068.6042249 10000;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision" #create a gdb arcpy.CreateFileGDB_management(current_dir, fgdb_name) # Create the coded value domains # You can add additional domains below arcpy.CreateDomain_management(workspace_path, 'GNSSFixType', 'GNSSFixType', 'SHORT', 'CODED', 'DUPLICATE', 'DEFAULT') arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 0, 'Fix not valid') arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 1, 'GPS') arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 2, 'Differential GPS') arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 4, 'RTK Fixed') arcpy.AddCodedValueToDomain_management(workspace_path, 'GNSSFixType', 5, 'RTK Float') arcpy.CreateDomain_management(workspace_path, 'Conditions', 'Sky Conditions', 'SHORT', 'CODED', 'DUPLICATE', 'DEFAULT') arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 1, 'open sky') arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 2, 'partiallyobscurred<25%') arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 3, 'marginallyobscurred<50%') arcpy.AddCodedValueToDomain_management(workspace_path, 'Conditions', 4, 'highlyobscurred<75%') arcpy.CreateDomain_management(workspace_path, "NumSatellites", "NumSatellites", "SHORT", "RANGE", "DEFAULT", "DEFAULT") arcpy.SetValueForRangeDomain_management(workspace_path, "NumSatellites", 0, 99) print('All done. Your fgdb was created at ' + workspace_path) print('Your feature class is called ' + fc_name)
def AddRangeDomain(feature, workspace, domain_name, range_low, range_high): """ Applies the range domain to the feature. Removes domain from any existing features if necessary. :param feature: a feature class :param workspace: the project's unique gdb :param domain_name: the name of the domain as a string :param range_low: integer or float :param range_high: integer or float :return: None """ # Check for existence of domain; update domain if present, add domain if # not desc = arcpy.Describe(workspace) domains = desc.domains if domain_name in domains: arcpy.AddMessage(domain_name + " is already specified as a domain") try: # try removing from all fields in all feature classes existingFeatures = arcpy.ListFeatureClasses() for existingFeature in existingFeatures: fields = arcpy.ListFields(existingFeature) for field in fields: if field.domain == domain_name: table = os.path.join(workspace, existingFeature) arcpy.RemoveDomainFromField_management( table, field.name) arcpy.AddMessage(domain_name + " domain removed from " + existingFeature + " " + field.name + " field") # try removing from all fields in all subtypes subtypes = arcpy.da.ListSubtypes(existingFeature) for stcode, stdict in list(subtypes.items()): for stkey in list(stdict.keys()): # if there is a Subtype Field if not stdict['SubtypeField'] == '': st_code = "'{}: {}'".format(stcode, stdict['Name']) # if no Subtype Field, use "#" in RemoveDomainFromField # for subtype_code else: st_code = "#" if stkey == 'FieldValues': fields = stdict[stkey] for field, fieldvals in list(fields.items()): # if field has a domain if not fieldvals[1] is None: # and the domain is in our list if fieldvals[1].name == domain_name: # remove the domain arcpy.AddMessage(fieldvals[1].name + " domain removed " + "from " + existingFeature + " field: " + field + " subtype: " + st_code) arcpy.RemoveDomainFromField_management( existingFeature, field, st_code) arcpy.DeleteDomain_management(workspace, domain_name) arcpy.CreateDomain_management(workspace, domain_name, domain_name + " must be integer", "SHORT", "RANGE") arcpy.SetValueForRangeDomain_management(workspace, domain_name, range_low, range_high) arcpy.AssignDomainToField_management(feature, domain_name, domain_name) arcpy.AddMessage(domain_name + " domain updated") except arcpy.ExecuteError: arcpy.AddMessage(domain_name + " domain could not be updated") else: arcpy.CreateDomain_management(workspace, domain_name, domain_name + " must be integer", "SHORT", "RANGE") arcpy.SetValueForRangeDomain_management(workspace, domain_name, range_low, range_high) arcpy.AssignDomainToField_management(feature, domain_name, domain_name) arcpy.AddMessage(domain_name + " domain updated")
arcpy.AddCodedValueToDomain_management(workspace, domDict, code, code) except: arcpy.AddWarning("Geen domein toegevoegd! Is al aanwezig.") # Range Domein voor de ruwheden aanmaken 0.5-1.0 arcpy.AddMessage("Domein Ruwheid aanmaken...") try: arcpy.CreateDomain_management(in_workspace=workspace, domain_name="Ruwheid", domain_description="Ruwheid", field_type="FLOAT", domain_type="RANGE", split_policy="DEFAULT", merge_policy="DEFAULT") arcpy.SetValueForRangeDomain_management(in_workspace=workspace, domain_name="Ruwheid", min_value="0.5", max_value="1.0") except: arcpy.AddWarning("Geen domein toegevoegd. Is al aanwezig!") arcpy.AddWarning("\n") #--------------------------------------------------------- #--------------------------------------------------------- # Nu de kolommen toevoegen incl. domein #--------------------------------------------------------- for kol in Kols: if kol[2] == "": try: arcpy.AddMessage("Kolom " + str(kol[0]) + " toevoegen...") arcpy.AddField_management(VakFC, kol[0], kol[1]) except: arcpy.AddError(