def create(self, template=None):
retval = arcpy.CreateTable_management(self.gname, self.tname, template)
DisplayMessages()
return retval
def MakeUPDisaggWeightsTable(UPConfig, ts, lu):
'''
Create an empty table to hold distance data in the database.
Only call this if you want to create a new table. This
function is not intended to overwite exising versions.
Called By:
WriteDisaggWeightsByLu
Calls:
Arguments:
UPConfig
'''
if not arcpy.Exists(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights')):
Logger("Creating New up_disagg_weights table")
arcpy.env.overwriteOutput = False
arcpy.CreateTable_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname']), 'up_disagg_weights')
arcpy.AddField_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'timestep', 'TEXT', "", "", 8)
arcpy.AddField_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'lu', 'TEXT', "", "", 8)
arcpy.AddField_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'attracter', 'TEXT', "", "", 50)
arcpy.AddField_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
UPConfig['BaseGeom_id'], 'LONG')
arcpy.AddField_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'weight', 'DOUBLE')
arcpy.AddIndex_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'timestep', 'timestep_wt_idx')
arcpy.AddIndex_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'lu', 'lu_wt_idx')
arcpy.AddIndex_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
'attracter', 'attracter_wt_idx')
arcpy.AddIndex_management(
os.path.join(UPConfig['paths']['dbpath'],
UPConfig['paths']['dbname'], 'up_disagg_weights'),
UPConfig['BaseGeom_id'],
"_".join([UPConfig['BaseGeom_id'], 'wt', 'idx']))
Logger("Created New up_disagg_weights table")
else:
Logger("up_disagg_weights table already exists, skipping")
pripct.append(1.0 - (np.sum(parceltable['pri_scr'] > parceltable['pri_scr'][j])/float(nparcels)))
new_table = rec_append_fields(parceltable, 'pri_pct', data = pripct, dtypes = '<f8')
new_table = new_table[new_table['pri_pct'].argsort()]
ranktable = AutoName(muni + '_rnkst')
out_table = os.path.join(workspace, os.path.basename(ranktable))
arcpy.da.NumPyArrayToTable(new_table, out_table)
muniparcelnames.append(out_table)
arcpy.Delete_management(muniname)
arcpy.AddMessage("Finished scoring " + muni + " parcels")
## Create an empty feature class with the desired schema
outfile = AutoName('Parcels_' + theme)
arcpy.CreateTable_management(workspace, outfile, muniparcelnames[0])
# Append all municipal files onto empty feature class with appropriate schema
arcpy.AddMessage("Re-merging municipalities")
arcpy.Append_management(muniparcelnames, outfile, schema_type = "TEST")
dropfields = ["TN_pctile_scr", "TP_pctile_scr", "TSS_pctile_scr", "aulsite_scr",
"hsgtype_scr", "OBJECTID_1", "Shape_1", "Shape_2", "LU_type",
"Code_3_12", "Code_1_2", "Code_Parcel_Database",
"Desc_Parcel_Database", "Desc_full"]
arcpy.DeleteField_management(outfile, dropfields)
for k in range(len(muniparcelnames)):
arcpy.Delete_management(muniparcelnames[k])
#Create table
gdb_and_table = os.path.join(gdb, tablename)
if arcpy.Exists(gdb):
arcpy.AddMessage(gdb + " already exists.")
else:
arcpy.AddMessage("Creating " + gdb)
arcpy.CreateFileGDB_management(
os.path.split(gdb)[0], os.path.basename(gdb))
if arcpy.Exists(os.path.join(gdb, tablename)):
arcpy.AddMessage('Table Exists')
else:
arcpy.AddMessage('Creating Table.')
arcpy.CreateTable_management(gdb, tablename)
## Add fields to table
arcpy.AddField_management(gdb_and_table, fields[0], 'TEXT', "", "", 48)
arcpy.AddField_management(gdb_and_table, fields[1], "LONG", "", "", "")
## Insert data into table
c = arcpy.da.InsertCursor(gdb_and_table, fields)
for row in json_rows:
arcpy.AddMessage(row)
c.insertRow(row)
del c
## Join Table to Existing feature class
country_join_field = 'NAME'
arcpy.CopyFeatures_management(country_fc, new_country_fc)
def to_table(geo, location, overwrite=True):
"""
Exports a geo enabled dataframe to a table.
=========================== ====================================================================
**Argument** **Description**
--------------------------- --------------------------------------------------------------------
location Required string. The output of the table.
--------------------------- --------------------------------------------------------------------
overwrite Optional Boolean. If True and if the table exists, it will be
deleted and overwritten. This is default. If False, the table and
the table exists, and exception will be raised.
=========================== ====================================================================
:returns: String
"""
out_location= os.path.dirname(location)
fc_name = os.path.basename(location)
df = geo._data
if location.lower().find('.csv') > -1:
geo._df.to_csv(location)
return location
elif HASARCPY:
columns = df.columns.tolist()
join_dummy = "AEIOUYAJC81Z"
try:
columns.pop(columns.index(df.spatial.name))
except:
pass
dtypes = [(join_dummy, np.int64)]
if overwrite and arcpy.Exists(location):
arcpy.Delete_management(location)
elif overwrite == False and arcpy.Exists(location):
raise ValueError(('overwrite set to False, Cannot '
'overwrite the table. '))
fc = arcpy.CreateTable_management(out_path=out_location,
out_name=fc_name)[0]
# 2. Add the Fields and Data Types
#
oidfld = da.Describe(fc)['OIDFieldName']
for col in columns[:]:
if col.lower() in ['fid', 'oid', 'objectid']:
dtypes.append((col, np.int32))
elif df[col].dtype.name == 'datetime64[ns]':
dtypes.append((col, '<M8[us]'))
elif df[col].dtype.name == 'object':
try:
u = type(df[col][df[col].first_valid_index()])
except:
u = pd.unique(df[col].apply(type)).tolist()[0]
if issubclass(u, str):
mlen = df[col].str.len().max()
dtypes.append((col, '<U%s' % int(mlen)))
else:
try:
dtypes.append((col, type(df[col][0])))
except:
dtypes.append((col, '<U254'))
elif df[col].dtype.name == 'int64':
dtypes.append((col, np.int64))
elif df[col].dtype.name == 'bool':
dtypes.append((col, np.int32))
else:
dtypes.append((col, df[col].dtype.type))
array = np.array([],
np.dtype(dtypes))
arcpy.da.ExtendTable(fc,
oidfld, array,
join_dummy, append_only=False)
# 3. Insert the Data
#
fields = arcpy.ListFields(fc)
icols = [fld.name for fld in fields \
if fld.type not in ['OID', 'Geometry'] and \
fld.name in df.columns]
dfcols = [fld.name for fld in fields \
if fld.type not in ['OID', 'Geometry'] and\
fld.name in df.columns]
with da.InsertCursor(fc, icols) as irows:
for idx, row in df[dfcols].iterrows():
try:
irows.insertRow(row.tolist())
except:
print("row %s could not be inserted." % idx)
return fc
return
def geoenrich(directory, featureset, gis_env_config, csv_uri):
"""Intakes a tax parcel shapefile, modifies fields, reprojects, then joins to BS&A table data. The final layer is
copied to a geodatabase feature class."""
# Create temporary geodatabase and set path variables
print('Creating temporary geodatabase...')
gdb_name = 'temp.gdb'
arcpy.CreateFileGDB_management(directory, gdb_name)
gdb_path = os.path.join(directory, gdb_name)
# GIS environment settings
arcpy.env.workspace = gdb_path
arcpy.env.qualifiedFieldNames = False
arcpy.env.overwriteOutput = gis_env_config['overwrite_output']
# FeatureSet to FeatureClass (ArcGIS API for Python)
print('Saving feature set to temporary geodatabase feature class...')
featureset.save(gdb_path, 'fc_orig_parcel')
# Correct field names (feature class)
print('Correcting field names...')
for field_prop in field_lst_fc:
arcpy.AlterField_management('fc_orig_parcel', field_prop[0],
field_prop[1], field_prop[2])
# Delete unnecessary fields (feature class)
print('Deleting unnecessary fields...')
arcpy.DeleteField_management('fc_orig_parcel', dropFields_fc)
# Modify projection if necessary
print('Assessing coordinate system...')
in_spatial_ref = arcpy.Describe('fc_orig_parcel').spatialReference
out_spatial_ref = arcpy.SpatialReference(gis_env_config['out_fc_proj'])
print(f'Current Spatial Reference: {in_spatial_ref.name}')
print(f'Output Spatial Reference: {out_spatial_ref.name}')
if in_spatial_ref.name == 'Unknown':
change_proj = False
print(
'Could not change projection due to undefined input coordinate system'
)
elif in_spatial_ref.name == out_spatial_ref.name:
change_proj = False
print('Input and output coordinate systems are the same')
else:
change_proj = True
print('Modifying output coordinate system...')
# Output final_lyr to enterprise geodatabase feature class
print('Copying features to temporary geodatabase feature class...')
if change_proj:
print('Changing projection, making feature layer...')
arcpy.Project_management('fc_orig_parcel', 'fc_proj_parcel',
out_spatial_ref)
arcpy.MakeFeatureLayer_management('fc_proj_parcel', 'parcel_lyr')
else:
print('Making feature layer...')
arcpy.MakeFeatureLayer_management('fc_orig_parcel', 'parcel_lyr')
# Convert CSV to GDB table
print('Finding table...')
arcpy.TableToTable_conversion(csv_uri, gdb_path, 'bsa_export')
# Create empty table to load bsa_export data
arcpy.CreateTable_management(gdb_path, 'join_table')
# Add fields from field_lst_tbl
for field in field_lst_tbl:
if field[1] == 'TEXT':
arcpy.AddField_management('join_table',
field[0],
field[1],
field_alias=field[2],
field_length=field[3])
else:
arcpy.AddField_management('join_table',
field[0],
field[1],
field_alias=field[2])
# Create FieldMappings object to manage merge output fields
field_mappings = arcpy.FieldMappings()
# Add the target table to the field mappings class to set the schema
field_mappings.addTable('join_table')
# Map fields from bsa_export table
for field in field_lst_tbl:
if field[4] is not None:
fld_map = arcpy.FieldMap()
fld_map.addInputField('bsa_export', field[4])
# Set name of new output field
field_name = fld_map.outputField
field_name.name, field_name.type, field_name.aliasName = field[
0], field[1], field[2]
fld_map.outputField = field_name
# Add output field to field mappings object
field_mappings.addFieldMap(fld_map)
# Append the bsa_export data into the join_table
arcpy.Append_management('bsa_export',
'join_table',
schema_type='NO_TEST',
field_mapping=field_mappings)
# Create expressions for field calculations
pin_exp = 'format_pin(!PNUM!, !RELATEDPNUM!)'
bsa_url_exp = 'format_bsaurl(!PNUM!)'
data_export_exp = 'datetime.now()'
acres_recorded_exp = 'find_acres_recorded(!LEGALDESC!)'
# Calculate fields
print('Calculating fields...')
arcpy.CalculateField_management('join_table', 'PIN', pin_exp, 'PYTHON3')
arcpy.CalculateField_management('join_table', 'BSAURL', bsa_url_exp,
'PYTHON3')
arcpy.CalculateField_management('join_table', 'DATAEXPORT',
data_export_exp, 'PYTHON3')
arcpy.CalculateField_management('join_table', 'ACRESRECORDED',
acres_recorded_exp, 'PYTHON3')
# Join parcel_lyr to bsa_export table
print('Joining table to parcel layer...')
arcpy.AddJoin_management('parcel_lyr', 'PIN', 'join_table', 'PIN')
arcpy.CopyFeatures_management('parcel_lyr', 'fc_join_parcel')
# Calculate Acres field
if gis_env_config[
'out_fc_proj'] == 'NAD 1983 StatePlane Michigan South FIPS 2113 (Intl Feet)':
print('Calculating acres...')
arcpy.CalculateGeometryAttributes_management('fc_join_parcel',
[['acres', 'AREA']],
area_unit='ACRES')
# Reorder fields
print('Reordering fields...')
reorder_fields('fc_join_parcel', 'fc_ordered_parcel', final_field_order)
arcpy.DeleteField_management('fc_ordered_parcel', dropFields_fc_final)
lyr_final_parcel = 'lyr_final_parcel'
arcpy.MakeFeatureLayer_management('fc_ordered_parcel', lyr_final_parcel)
return gdb_path, lyr_final_parcel
def execute(self, parameters, messages):
"""The source code of the tool."""
arcpy.env.workspace = parameters[0].value
# Number of low IDs per hi ID
# Higher batch sizes mean less updating of the table, lower batch sizes more
# efficient ID usage especially when multiple processes access the table.
hi_batchsize = parameters[2].value
# Name of the table used to maintain hi/lo counter status per feature class. Could also become a parameter.
generate_ID_table_name = "GenerateID"
# check whether sequences table has already been created.
new_table = None
counter_tbl_list = arcpy.ListTables(generate_ID_table_name)
if not counter_tbl_list:
arcpy.AddMessage("Creating new GenerateID table.")
new_table = True
generate_ID_table = arcpy.CreateTable_management(arcpy.env.workspace, generate_ID_table_name)
arcpy.AddField_management(generate_ID_table, "name", "TEXT", None, None, 50, "Feature Class Name", "NON_NULLABLE", "REQUIRED")
arcpy.AddField_management(generate_ID_table, "hi", "LONG", None, None, None, "Hi counter", "NON_NULLABLE", "REQUIRED")
arcpy.AddField_management(generate_ID_table, "low", "LONG", None, None, None, "Low counter", "NON_NULLABLE", "REQUIRED")
else:
new_table = False
generate_ID_table = counter_tbl_list[0]
# go through feature classes to create FIDs where needed.
fc_list = arcpy.ListFeatureClasses()
for fc in fc_list:
arcpy.AddMessage("Processing " + fc)
hi_counter = 0
low_counter = 0
# if we only created the GenerateID table, we know we have to insert the counter.
if new_table:
insert_new_counter_cursor = arcpy.da.InsertCursor(generate_ID_table_name, ["name", "hi", "low"])
insert_new_counter_cursor.insertRow((fc, 0, 0))
del insert_new_counter_cursor
# check if a counter of fc_name exists and retrieve value
with arcpy.da.SearchCursor(generate_ID_table_name, ["name", "hi", "low"]) as rows:
for row in rows:
if row[0] == fc:
hi_counter = row[1]
low_counter = row[2]
break
# increment hi counter to indicate that it is in active usage
with arcpy.da.UpdateCursor(generate_ID_table_name, ["name", "hi"]) as rows:
for row in rows:
if row[0] == fc:
row[1] = 1 + hi_counter
rows.updateRow(row)
break
# check if feature class alread has a FID, add it if not.
fid_name = fc + "FID"
fields_list = arcpy.ListFields(fc, fid_name)
if not fields_list:
arcpy.AddField_management(fc, fid_name, "TEXT", None, None, 50, "Feature ID", None, None)
# modify FID of object if required
with arcpy.da.UpdateCursor(fc, [fid_name]) as rows:
for row in rows:
if row[0] == None:
if low_counter >= hi_batchsize:
# update hi_counter, reset low_counter
arcpy.AddMessage("Hi Sequence " + str(hi_counter) + " exhausted, using next Sequence.")
escaped_name = arcpy.AddFieldDelimiters(generate_ID_table_name, "name")
where_clause = escaped_name + " = " + "'" + fc + "'"
new_hi_row = [row[0] for rows in arcpy.da.SearchCursor(generate_ID_table_name, ["hi"], where_clause)]
hi_counter = new_hi_row[0]
low_counter = 0
row[0] = fc + "/" + str(hi_counter * hi_batchsize + low_counter)
low_counter += 1
rows.updateRow(row)
# write back the new low value to the GenerateID table.
with arcpy.da.UpdateCursor(generate_ID_table_name, ["name", "low"]) as rows:
for newRow in rows:
if newRow[0] == fc:
newRow[1] = low_counter
rows.updateRow(newRow)
break
arcpy.AddMessage("Completed adding of Feature IDs.")
return
fieldobjs.append(r.orgdoc)
fieldobjs.append(r.id + str(r.timest))
fieldobjs.append(r.linkdetails)
fieldobjs.append((r.long, r.lat))
iCur.insertRow(fieldobjs)
del iCur
# ----------------------------------
# Build non-geo entities table
# ----------------------------------
nongeotablename = "netowl_entities"
if arcpy.Exists(nongeotablename) is False:
arcpy.CreateTable_management(wk, nongeotablename,
"netowl_template_nogeo") # noqa: E501
iCur_links = arcpy.da.InsertCursor(
nongeotablename,
["RDFID", "RDFVALUE", "TIMEST", "RDFLINKS", "ORGDOC", "UNIQUEID", "TYPE"
]) # noqa: E501
for d in rdfobjs:
fieldobjs = []
fieldobjs.append(d.id)
fieldobjs.append(d.value)
fieldobjs.append(d.timest)
ll = nof.make_link_list(d.links)
fieldobjs.append(ll)
fieldobjs.append(d.orgdoc)
## Make all the feature datasets and feature classes we will use
#Create the feature dataset where the empty geological features will be stored
arcpy.CreateFeatureDataset_management(workingGDBPath, digitisingFDName, coordinateSystem)
#Create the feature class for contacts
arcpy.CreateFeatureclass_management(digitisingFDName, contactsFCName, "POLYLINE")
#Create the feature class for map boundary
arcpy.CreateFeatureclass_management(digitisingFDName, boundaryFCName, "POLYGON")
##Preparing the Valid Units table
#create the table of Valid Units
arcpy.CreateTable_management(workingGDBPath, validUnitTableName)
#add the Unit Code field to the Valid Units Table
arcpy.AddField_management(validUnitTableName,unitCodeFieldName,"TEXT","")
#add the Unit Name field to the Valid Units Table
arcpy.AddField_management(validUnitTableName,unitNameFieldName,"TEXT","")
##Create accuracy field in the contacts feature class and add sub type containing valid accuracy types
#add the accuracy field
arcpy.AddField_management(os.path.join(digitisingFDName,contactsFCName),accuracyFieldName,"LONG","")
#Create empty sub type to go in the Accuracy Field
arcpy.SetSubtypeField_management(os.path.join(digitisingFDName,contactsFCName),accuracyFieldName)
climatedata = r'{}\TempFeuchte'.format(data)
fk = ExtractByMask(Raster(r'{}\fk_von_L'.format(data)), basin)
rp = fk * rp_factor
wp = ExtractByMask(Raster(r'{}\wp'.format(data)), basin)
water = ExtractByMask(Raster(r'{}\Gewaesser'.format(data)), basin)
rpwp_dif = rp - wp
s_pre = s_init
p_data = r'{}\N_Zeitreihen'.format(data)
cellsize = s_init.meanCellHeight
lambda_parameter = (
c /
(ExtractByMask(Raster(r'{}\L_in_metern'.format(data)), basin) * 1000)**2)
# Erstellen der Ergebnistabelle
result_path = arcpy.CreateTable_management(
r'{}\Ergebnistabellen.gdb'.format(workspace), outname)
arcpy.AddField_management(result_path, "Datum", "TEXT")
arcpy.AddField_management(result_path, "Q", "DOUBLE")
arcpy.AddMessage(
time.strftime("%H:%M:%S: ") +
"Berechnung der Rasterdatensaetze war erfolgreich.")
########################################################################################################################
# Beginn des Hauptprogramms
# Start der Modellierung
# Iteration durch die Klimadaten des Untersuchungszeitraums
########################################################################################################################
with arcpy.da.SearchCursor(
climatedata, ['Tagesid', 'Jahr', 'Monat', 'Tag', 'RelFeu', 'Temp'],
#
# Locate Features Along Routes: locate selected TMCs along selected MassDOT route
# Output is: tmc_event_table
# Note: An XY tolerance of ***40*** meters was found to be necessary some cases, e.g., I-95 @ new bridge over Merrimack River.
# tmc_event_table_properties = "route_id LINE from_meas to_meas"
# arcpy.LocateFeaturesAlongRoutes_lr(INRIX_TMCS, Selected_LRSN_Route, "route_id", XY_tolerance + " Meters", tmc_event_table,
# tmc_event_table_properties, "FIRST", "DISTANCE", "ZERO", "FIELDS", "M_DIRECTON")
# Delete un-needed fields from tmc_event_table
# arcpy.DeleteField_management(tmc_event_table, "linrtmc;frc;lenmiles;strtlat;strtlong;endlat;endlong;roadname;country;state;zipcode")
#
# *** End of original code
#
# *** Beginning of replacement code:
#
# Make a copy of the "template" TMC event table into which the raw (unsorted) TMC events will be written
arcpy.CreateTable_management(tmc_event_table_gdb, tmc_event_table_name_raw,
tmc_template_event_table)
# Indices in the vector of fields (i.e., attributes) to be read in from the TMC FC
route_feat_route_id_ix = 0
route_feat_shape_ix = 1
#
# Get the geometry of the selected LRSN route
route_sc = arcpy.da.SearchCursor(Selected_LRSN_Route, ['route_id', 'shape@'])
route_feat = route_sc.next()
route_feat_last_m_value = route_feat[route_feat_shape_ix].lastPoint.M
# Names of fields (i.e., attributes) read in from the TMC FC
tmc_fc_fieldnames = [
'tmc', 'tmctype', 'roadnum', 'firstnm', 'direction', 'shape@'
]
# Indices in the vector of fields (i.e., attributes) read in from the TMC FC
spatial_reference = arcpy.Describe(titleFC).spatialReference
#TABLE VIEW
titles_table = os.path.join(sde_connection, config.owner_table)
arcpy.MakeTableView_management (titles_table, "table_titles")
#SELECT BY LOCATION
arcpy.SelectLayerByLocation_management("title_lyr", "WITHIN_A_DISTANCE", addr, distance, "NEW_SELECTION")
#arcpy.CopyFeatures_management('title_lyr', "in_memory/selected_title")
#TABLE JOIN TITLE PARCELS
owners_fl = arcpy.AddJoin_management ("title_lyr", "PID", "table_titles", "PID")
#arcpy.CopyFeatures_management("title_lyr", "tableTest")
#FORMAT THE TABLE TO A STANDARD FORMAT WE USE - EXPORT AS A RECORD SET
owners_table = arcpy.CreateTable_management("in_memory", "owners_table")
#ADD FIELDS TO THE TABLE
fields = [
("PID","TEXT"),
("owner_count","TEXT"),
("owner_name","TEXT"),
("owner_address","TEXT"),
("postal_code","TEXT"),
("province","TEXT")
]
for field in fields:
arcpy.AddField_management(*(owners_table,) + field)
fieldList = arcpy.ListFields("title_lyr")
if not arcpy.Exists(subdir_fc2 + '\\' + folder3):
arcpy.CreateFolder_management(subdir_fc2, folder3)
if not arcpy.Exists(subdir_fc2 + '\\' + folder4):
arcpy.CreateFolder_management(subdir_fc2, folder4)
if not arcpy.Exists(subdir_fc2 + '\\' + folder5):
arcpy.CreateFolder_management(subdir_fc2, folder5)
if not arcpy.Exists(subdir_fc2 + '\\' + folder6):
arcpy.CreateFolder_management(subdir_fc2, folder6)
if fc_one == fc_two or round_trip is False:
directory = subdir
else:
directory = subdir_fc1
# Creates dummy table to store results of each pairwise iteration of the analysis.
table = arcpy.CreateTable_management(directory, 'maintable.dbf')
arcpy.AddField_management(table, 'Source', 'TEXT')
arcpy.AddField_management(table, 'Dest', 'TEXT')
arcpy.AddField_management(table, 'PathCost', 'FLOAT')
arcpy.AddField_management(table, 'Distance', 'FLOAT')
fields = ['Source', 'Dest', 'PathCost', 'Distance']
# Creates log file
log = open(directory + '\log' + str(int(time()))[-8:] + '.txt', 'a+')
log.write('------------------------------------------------------------------------------------------' + '\n')
log.write('Event log for least cost path analysis between locations in: ' + '\n')
log.write(fc_one + '\n')
log.write(fc_two + '\n')
log.write('Event log created: ' + asctime() + '\n')
log.write('------------------------------------------------------------------------------------------' + '\n')
self.data = data
if __name__ == '__main__':
try:
# Start time recording
startTime = time()
startTimeStr = strftime('%m-%d-%Y %H:%M:%S')
print 'Starting program: ', startTimeStr, '\n'
#create output table
if arcpy.Exists(outTable):
arcpy.Delete_management(outTable)
arcpy.CreateTable_management(outTableLocation, outTableName)
#add featureID field
if not findField(outTable, uniqueFeatureIDfield):
arcpy.AddField_management(outTable, uniqueFeatureIDfield, 'TEXT',
'', '', 20)
#add fields for each possible value in categorical raster
if analysisType == 'categorical':
arcpy.AddField_management(outTable, fieldPrefix + '0', 'DOUBLE',
'', '', 20)
for row in arcpy.da.SearchCursor(inRaster, uniqueRasterIDfield):
if not findField(outTable, fieldPrefix + str(row[0])):
arcpy.AddField_management(outTable,
fieldPrefix + str(row[0]),
'DOUBLE', '', '', 20)
def SLEM(Line, Distance, Output, TF):
CopyLine = arcpy.CopyFeatures_management(Line, r"in_memory\CopyLine")
fieldnames = [f.name for f in arcpy.ListFields(CopyLine)]
#/identification of the polyline type : raw, UGOs, sequenced UGOs, or AGOs
k = 0
if "Rank_AGO" in fieldnames:
k = 3
elif "Order_ID" in fieldnames:
k = 2
elif "Rank_UGO" in fieldnames:
k = 1
################################
########## Raw polyline ########
################################
if k == 0:
#/shaping of the segmented result
arcpy.AddField_management(CopyLine, "Rank_UGO", "LONG", "", "", "", "",
"NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "Rank_UGO",
"!" + fieldnames[0] + "!",
"PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "",
"", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "From_Measure", "0",
"PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "",
"", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "To_Measure",
"!shape.length!", "PYTHON_9.3", "")
#/conversion in routes
LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO",
r"in_memory\LineRoutes",
"TWO_FIELDS", "From_Measure",
"To_Measure")
#/creation of the event table
PointEventTEMP = arcpy.CreateTable_management("in_memory",
"PointEventTEMP", "", "")
arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "",
"", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "",
"", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "",
"", "NULLABLE", "NON_REQUIRED", "")
UPD_SL.UpToDateShapeLengthField(LineRoutes)
rowslines = arcpy.SearchCursor(LineRoutes)
rowsevents = arcpy.InsertCursor(PointEventTEMP)
for line in rowslines:
tempdistance = float(line.Shape_Length)
while (tempdistance > float(0)):
row = rowsevents.newRow()
row.Rank_UGO = line.Rank_UGO
row.To_M = max(0, tempdistance - float(Distance))
row.Distance = tempdistance
rowsevents.insertRow(row)
tempdistance = tempdistance - float(Distance)
del rowslines
del rowsevents
#/creation of the route event layer
MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(
LineRoutes, "Rank_UGO", PointEventTEMP,
"Rank_UGO LINE Distance To_M", r"in_memory\MakeRouteEventTEMP")
Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP,
r"in_memory\Split", "", "0", "0",
"0")
Sort = arcpy.Sort_management(
Split, Output,
[["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]])
arcpy.DeleteField_management(Sort, "To_M")
#/calculation of the "Distance" field
UPD_SL.UpToDateShapeLengthField(Sort)
rows1 = arcpy.UpdateCursor(Sort)
rows2 = arcpy.UpdateCursor(Sort)
line2 = rows2.next()
line2.Distance = 0
rows2.updateRow(line2)
nrows = int(str(arcpy.GetCount_management(Sort)))
n = 0
for line1 in rows1:
line2 = rows2.next()
if n == nrows - 1:
break
if n == 0:
line1.Distance = 0
if line2.Rank_UGO == line1.Rank_UGO:
line2.Distance = line1.Distance + line1.Shape_Length
rows2.updateRow(line2)
if line2.Rank_UGO != line1.Rank_UGO:
line2.Distance = 0
rows2.updateRow(line2)
n += 1
#/deleting of the temporary files
if str(TF) == "true":
arcpy.Delete_management(Split)
arcpy.Delete_management(CopyLine)
arcpy.Delete_management(LineRoutes)
arcpy.Delete_management(PointEventTEMP)
return Sort
def makeTable():
txtFile = arcpy.GetParameterAsText(0)
newTB = arcpy.GetParameterAsText(1)
arcpy.CreateTable_management(
os.path.dirname(newTB),
os.path.basename(newTB),
)
#Add attribute fields to table
arcpy.AddField_management(newTB, "NodeID", "long")
arcpy.AddField_management(newTB, "Value1", "float")
arcpy.AddField_management(newTB, "Value2", "float")
arcpy.AddField_management(newTB, "Value3", "float")
arcpy.AddField_management(newTB, "Value4", "float")
arcpy.AddField_management(newTB, "Value5", "float")
arcpy.AddField_management(newTB, "Value6", "float")
arcpy.AddField_management(newTB, "Value7", "float")
arcpy.AddField_management(newTB, "Value8", "float")
arcpy.AddField_management(newTB, "Value9", "float")
arcpy.AddField_management(newTB, "Value10", "float")
arcpy.AddField_management(newTB, "Value11", "float")
arcpy.AddField_management(newTB, "Value12", "float")
#Open the text file and read the number of nodes
input = file(txtFile, "r")
input.readline()
line = input.readline()
totalNodes = line.split() #Number of nodes
nunnodes = int(totalNodes[0])
line = input.readline()
data = line.split()
nunparameter = int(data[0]) #Number of attributes
print('This ADCIRC GRID has: ' + str(nunnodes) + ' nodes')
print('This Fort.13 file has: ' + str(nunparameter) + ' parameters')
print('Importing the parameters from the Fort.13 ...')
#Reads line until line with parameter
count = 0
while count == 0:
line = input.readline()
data = line.split()
if str(data[0]) == str(
"surface_directional_effective_roughness_length"):
count = +1
line = input.readline()
line = input.readline()
line = input.readline()
data = line.split()
defaultValue = float(data[0])
cur = arcpy.InsertCursor(newTB)
index = 1
for row in range(0, nunnodes):
row = cur.newRow()
row.NodeID = long(index)
row.Value1 = defaultValue
row.Value2 = defaultValue
row.Value3 = defaultValue
row.Value4 = defaultValue
row.Value5 = defaultValue
row.Value6 = defaultValue
row.Value7 = defaultValue
row.Value8 = defaultValue
row.Value9 = defaultValue
row.Value10 = defaultValue
row.Value11 = defaultValue
row.Value12 = defaultValue
cur.insertRow(row)
index = index + 1
del cur, row
#Adds non-default values
count2 = 0
while count2 == 0:
line = input.readline()
data = line.split()
if str(data[0]) == str(
'surface_directional_effective_roughness_length'):
count2 = +1
line = input.readline()
totalValues = line.split()
if int(line) > 0:
cur2 = arcpy.UpdateCursor(newTB)
for i in range(int(line)):
line = input.readline()
data = line.split()
tmpnode = long(data[0])
row = cur2.next()
tmpnode2 = row.NodeID
while tmpnode <> tmpnode2:
row = cur2.next()
tmpnode2 = row.NodeID
row.Value1 = float(data[1])
row.Value2 = float(data[2])
row.Value3 = float(data[3])
row.Value4 = float(data[4])
row.Value5 = float(data[5])
row.Value6 = float(data[6])
row.Value7 = float(data[7])
row.Value8 = float(data[8])
row.Value9 = float(data[9])
row.Value10 = float(data[10])
row.Value11 = float(data[11])
row.Value12 = float(data[12])
cur2.updateRow(row)
del row, cur2
line = input.readline()
arcpy.DeleteField_management(newTB, "Field1")
input.close()
def run(self):
params = self.par
projektname = self.projectname
lib_einnahmen.create_gemeindebilanzen(self, projektname)
fields = ['AGS', 'Gemeindetyp']
tablepath_rahmendaten = self.folders.get_table(
'Projektrahmendaten', "FGDB_Definition_Projekt.gdb")
cursor = arcpy.da.SearchCursor(tablepath_rahmendaten, fields)
for row in cursor:
ags = row[0]
gemeindetyp = row[1]
tablepath_gemeinden = self.folders.get_base_table(
"FGDB_Basisdaten_deutschland.gdb", "bkg_gemeinden")
tablepath_einkommen = self.folders.get_db("FGDB_Einnahmen.gdb",
params.name.value)
tablepath_hebesteuer = os.path.join(tablepath_einkommen,
"GrSt_Hebesatz_B")
fields = ["Hebesatz_GrStB"]
if arcpy.Exists(tablepath_hebesteuer):
cursor = arcpy.da.UpdateCursor(tablepath_hebesteuer, fields)
for row in cursor:
row[0] = params.slider1.value
cursor.updateRow(row)
else:
arcpy.CreateTable_management(
self.folders.get_db("FGDB_Einnahmen.gdb", params.name.value),
"GrSt_Hebesatz_B")
arcpy.AddField_management(tablepath_hebesteuer, "Hebesatz_GrStB",
"LONG")
cursor = arcpy.da.InsertCursor(tablepath_hebesteuer, fields)
cursor.insertRow([params.slider1.value])
fields = [
"EFH_Rohmiete", 'DHH_Rohmiete', 'RHW_Rohmiete', 'MFH_Rohmiete',
'Bodenwert_Sachwertverfahren', 'qm_Grundstueck_pro_WE_EFH',
'BGF_Buero', 'BGF_Halle'
]
tablepath_basisdaten = self.folders.get_table('GrSt_Basisdaten',
"FGDB_Einnahmen.gdb")
cursor = arcpy.da.UpdateCursor(tablepath_basisdaten, fields)
for row in cursor:
cursor.deleteRow()
cursor = arcpy.da.InsertCursor(tablepath_basisdaten, fields)
cursor.insertRow([
params.slider2.value, params.slider3.value, params.slider4.value,
params.slider5.value, params.slider6.value, params.slider7.value,
params.slider8.value, params.slider9.value
])
einheitswert_efh = 0
einheitswert_dh = 0
einheitswert_rh = 0
einheitswert_mfh = 0
wohnflaeche_efh = 0
wohnflaeche_dh = 0
wohnflaeche_rh = 0
wohnflaeche_mfh = 0
rohmiete_efh = 0
rohmiete_dh = 0
rohmiete_rh = 0
rohmiete_mfh = 0
garagen_efh = 0
garagen_dh = 0
garagen_rh = 0
garagen_mfh = 0
multiplikator_efh = 0
multiplikator_dh = 0
multiplikator_rh = 0
multiplikator_mfh = 0
table_wohnflaeche = self.folders.get_base_table(
"FGDB_Einnahmen_Tool.gdb", "GrSt_Wohnflaeche_und_Steuermesszahlen")
fields = [
"IDGebaeudetyp", "Mittlere_Wohnflaeche",
"Aufschlag_Garagen_Carport"
]
cursor = arcpy.da.SearchCursor(table_wohnflaeche, fields)
for row in cursor:
if row[0] == 1:
wohnflaeche_efh = row[1]
garagen_efh = row[2]
if row[0] == 2:
wohnflaeche_dh = row[1]
garagen_dh = row[2]
if row[0] == 3:
wohnflaeche_rh = row[1]
garagen_rh = row[2]
if row[0] == 4:
wohnflaeche_mfh = row[1]
garagen_mfh = row[2]
if int(ags) <= 10999999:
rohmiete_efh = params.slider2.value / 100.0
rohmiete_dh = params.slider3.value / 100.0
rohmiete_rh = params.slider4.value / 100.0
rohmiete_mfh = params.slider5.value / 100.0
else:
rohmiete_efh, rohmiete_dh, rohmiete_rh, rohmiete_mfh = 0.46
fields = ["AGS", "GemGroessKlass64"]
where_clause = '"AGS"' + "='" + ags + "'"
cursor = arcpy.da.SearchCursor(tablepath_gemeinden, fields,
where_clause)
for row in cursor:
gemeinde_klasse = row[1]
table_wohnflaeche = self.folders.get_base_table(
"FGDB_Einnahmen_Tool.gdb", "GrSt_Vervielfaeltiger")
where_clause = '"Gemeindegroessenklasse64"' + "='" + gemeinde_klasse + "'"
fields = [
"Gemeindegroessenklasse64", "IDGebaeudetyp", "Vervielfaeltiger"
]
cursor = arcpy.da.SearchCursor(table_wohnflaeche, fields, where_clause)
for row in cursor:
if row[1] == 1:
multiplikator_efh = row[2]
if row[1] == 2:
multiplikator_dh = row[2]
if row[1] == 3:
multiplikator_rh = row[2]
if row[1] == 4:
multiplikator_mfh = row[2]
einheitswert_efh = (12 * rohmiete_efh * wohnflaeche_efh +
garagen_efh) * multiplikator_efh
einheitswert_dh = (12 * rohmiete_dh * wohnflaeche_dh +
garagen_dh) * multiplikator_dh
einheitswert_rh = (12 * rohmiete_rh * wohnflaeche_rh +
garagen_rh) * multiplikator_rh
einheitswert_mfh = (12 * rohmiete_mfh * wohnflaeche_mfh +
garagen_mfh) * multiplikator_mfh
if int(ags) >= 11000000:
table_wohnflaeche = self.folders.get_base_table(
"FGDB_Einnahmen_Tool.gdb",
"GrSt_Wohnflaeche_und_Steuermesszahlen")
where_clause = '"IDGebaeudetyp"' + "='" + 1 + "'"
fields = ["IDGebaeudetyp", "Umbauter_Raum_m3"]
cursor = arcpy.da.SearchCursor(table_wohnflaeche, fields,
where_clause)
for row in cursor:
umbauter_raum_m3 = row[1]
einheitswert_efh = 24 / 1.95583 * umbauter_raum_m3 + 550 + params.slider7.value * (
params.slider6.value / 100.0)
if params.slider8.value != 0 or params.slider9.value != 0:
einheitswert_gewerbe = (1685 * params.slider8.value +
800 * params.slider9.value) * 0.1554
else:
einheitswert_gewerbe = 0
we_efh = 0
we_dh = 0
we_rh = 0
we_mfh = 0
fields = ['IDGebaeudetyp', 'WE']
tablepath_wohnen = self.folders.get_table(
'Wohnen_WE_in_Gebaeudetypen', "FGDB_Definition_Projekt.gdb")
cursor = arcpy.da.SearchCursor(tablepath_wohnen, fields)
for row in cursor:
if row[0] == 1:
we_efh += row[1]
if row[0] == 2:
we_dh += row[1]
if row[0] == 3:
we_rh += row[1]
if row[0] == 4:
we_mfh += row[1]
arcpy.AddMessage("Einheitswert EFH = {}".format(einheitswert_efh))
if einheitswert_efh <= 38346:
einheitswert_bis_38346_EUR_efh = einheitswert_efh
einheitswert_ab_38346_EUR_efh = 0
else:
einheitswert_bis_38346_EUR_efh = 38346
einheitswert_ab_38346_EUR_efh = einheitswert_efh - 38346
if einheitswert_dh <= 38346:
einheitswert_bis_38346_EUR_dh = einheitswert_dh
einheitswert_ab_38346_EUR_dh = 0
else:
einheitswert_bis_38346_EUR_dh = 38346
einheitswert_ab_38346_EUR_dh = einheitswert_dh - 38346
if einheitswert_rh <= 38346:
einheitswert_bis_38346_EUR_rh = einheitswert_rh
einheitswert_ab_38346_EUR_rh = 0
else:
einheitswert_bis_38346_EUR_rh = 38346
einheitswert_ab_38346_EUR_rh = einheitswert_rh - 38346
if einheitswert_mfh <= 38346:
einheitswert_bis_38346_EUR_mfh = einheitswert_mfh
einheitswert_ab_38346_EUR_mfh = 0
else:
einheitswert_bis_38346_EUR_mfh = 38346
einheitswert_ab_38346_EUR_mfh = einheitswert_mfh - 38346
table_wohnflaeche = self.folders.get_base_table(
"FGDB_Einnahmen_Tool.gdb", "GrSt_Wohnflaeche_und_Steuermesszahlen")
fields = [
"IDGebaeudetyp", "Steuermesszahl_bis_38346_EUR",
"Steuermesszahl_ab_38346_EUR"
]
cursor = arcpy.da.SearchCursor(table_wohnflaeche, fields)
for row in cursor:
if row[0] == 1:
steuermesszahl_bis_38346_EUR_efh = row[1]
steuermesszahl_ab_38346_EUR_efh = row[2]
if row[0] == 2:
steuermesszahl_bis_38346_EUR_dh = row[1]
steuermesszahl_ab_38346_EUR_dh = row[2]
if row[0] == 3:
steuermesszahl_bis_38346_EUR_rh = row[1]
steuermesszahl_ab_38346_EUR_rh = row[2]
if row[0] == 4:
steuermesszahl_bis_38346_EUR_mfh = row[1]
steuermesszahl_ab_38346_EUR_mfh = row[2]
messbetrag_efh = we_efh * (
einheitswert_bis_38346_EUR_efh * steuermesszahl_bis_38346_EUR_efh +
einheitswert_ab_38346_EUR_efh * steuermesszahl_ab_38346_EUR_efh)
messbetrag_dh = we_dh * (
einheitswert_bis_38346_EUR_dh * steuermesszahl_bis_38346_EUR_dh +
einheitswert_ab_38346_EUR_dh * steuermesszahl_ab_38346_EUR_dh)
messbetrag_rh = we_rh * (
einheitswert_bis_38346_EUR_rh * steuermesszahl_bis_38346_EUR_rh +
einheitswert_ab_38346_EUR_rh * steuermesszahl_ab_38346_EUR_rh)
messbetrag_mfh = we_mfh * (
einheitswert_bis_38346_EUR_mfh * steuermesszahl_bis_38346_EUR_mfh +
einheitswert_ab_38346_EUR_mfh * steuermesszahl_ab_38346_EUR_mfh)
messbetrag_gewerbe = einheitswert_gewerbe * 0.0035
def roundup(number, multiple):
num = number + (multiple - 1)
return num - (num % multiple)
GRUNDSTEUERAUFKOMMEN = (
messbetrag_efh + messbetrag_dh + messbetrag_rh + messbetrag_mfh +
messbetrag_gewerbe) * params.slider1.value / 100.0
table_bilanzen = self.folders.get_table("Gemeindebilanzen",
"FGDB_Einnahmen.gdb")
fields = ["AGS", "GrSt"]
cursor = arcpy.da.UpdateCursor(table_bilanzen, fields)
for row in cursor:
if row[0] == ags:
row[1] = GRUNDSTEUERAUFKOMMEN
else:
row[1] = 0
cursor.updateRow(row)
c.set_chronicle(
"Grundsteuer",
self.folders.get_table(tablename='Chronik_Nutzung',
workspace="FGDB_Einnahmen.gdb",
project=projektname))
field='Area_mi2',
expression=basin_area_mi2)
arcpy.SelectLayerByAttribute_management(in_layer_or_view=basins,
selection_type='CLEAR_SELECTION')
# calculate length-weighted slope
# 1. split longest flow path at regular points along the line
# 2. calculate slope of each split part
# 3. use the slopes and lengths to get the length-weighted slope
lfp_points = [
f for f in
arcpy.da.SearchCursor('{}\Layers\longestflowpath_{}.shp'.format(
HOME_DIRECTORY, i), ['SHAPE@X', 'SHAPE@Y'],
explode_to_points=True)
]
arcpy.CreateTable_management(PROCESS_GDB, 'lfp_points_table_{}'.format(i))
arcpy.AddField_management('{}lfp_points_table_{}'.format(PROCESS_GDB, i),
'X', 'DOUBLE')
arcpy.AddField_management('{}lfp_points_table_{}'.format(PROCESS_GDB, i),
'Y', 'DOUBLE')
with arcpy.da.InsertCursor('{}lfp_points_table_{}'.format(PROCESS_GDB, i),
['X', 'Y']) as cur:
for row in lfp_points:
cur.insertRow(row)
arcpy.MakeXYEventLayer_management(
'{}lfp_points_table_{}'.format(PROCESS_GDB, i), 'X', 'Y',
'lfp_points_layer')
arcpy.FeatureToPoint_management(
'lfp_points_layer', '{}/lfp_points_points_{}'.format(PROCESS_GDB, i))
arcpy.SplitLineAtPoint_management(
'{}/Layers/longestflowpath_{}.shp'.format(HOME_DIRECTORY, i),
def main(thisDB,coordSystem,nCrossSections):
# create feature dataset GeologicMap
addMsgAndPrint(' Creating feature dataset GeologicMap...')
try:
arcpy.CreateFeatureDataset_management(thisDB,'GeologicMap',coordSystem)
except:
addMsgAndPrint(arcpy.GetMessages(2))
# create feature classes in GeologicMap
# poly feature classes
featureClasses = ['MapUnitPolys']
for fc in ['DataSourcePolys','MapUnitOverlayPolys','OverlayPolys']:
if fc in OptionalElements:
featureClasses.append(fc)
for featureClass in featureClasses:
fieldDefs = tableDict[featureClass]
createFeatureClass(thisDB,'GeologicMap',featureClass,'POLYGON',fieldDefs)
# line feature classes
featureClasses = ['ContactsAndFaults']
for fc in ['GeologicLines','CartographicLines','IsoValueLines']:
if fc in OptionalElements:
featureClasses.append(fc)
if debug:
addMsgAndPrint('Feature classes = '+str(featureClasses))
for featureClass in featureClasses:
fieldDefs = tableDict[featureClass]
if featureClass in ['ContactsAndFaults','GeologicLines'] and addLTYPE:
fieldDefs.append(['LTYPE','String','NullsOK',50])
createFeatureClass(thisDB,'GeologicMap',featureClass,'POLYLINE',fieldDefs)
# point feature classes
featureClasses = []
for fc in ['OrientationPoints','GeochronPoints','FossilPoints','Stations',
'GenericSamples','GenericPoints']:
if fc in OptionalElements:
featureClasses.append(fc)
for featureClass in featureClasses:
if featureClass == 'MapUnitPoints':
fieldDefs = tableDict['MapUnitPolys']
if addLTYPE:
fieldDefs.append(['PTYPE','String','NullsOK',50])
else:
fieldDefs = tableDict[featureClass]
if addLTYPE and featureClass in ['OrientationPoints']:
fieldDefs.append(['PTTYPE','String','NullsOK',50])
createFeatureClass(thisDB,'GeologicMap',featureClass,'POINT',fieldDefs)
# create feature dataset CorrelationOfMapUnits
if 'CorrelationOfMapUnits' in OptionalElements:
addMsgAndPrint(' Creating feature dataset CorrelationOfMapUnits...')
arcpy.CreateFeatureDataset_management(thisDB,'CorrelationOfMapUnits',coordSystem)
fieldDefs = tableDict['CMUMapUnitPolys']
createFeatureClass(thisDB,'CorrelationOfMapUnits','CMUMapUnitPolys','POLYGON',fieldDefs)
fieldDefs = tableDict['CMULines']
createFeatureClass(thisDB,'CorrelationOfMapUnits','CMULines','POLYLINE',fieldDefs)
fieldDefs = tableDict['CMUPoints']
createFeatureClass(thisDB,'CorrelationOfMapUnits','CMUPoints','POINT',fieldDefs)
# create CrossSections
if nCrossSections > 26:
nCrossSections = 26
if nCrossSections < 0:
nCrossSections = 0
# note space in position 0
alphabet = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for n in range(1,nCrossSections+1):
xsLetter = alphabet[n]
xsName = 'CrossSection'+xsLetter
xsN = 'CS'+xsLetter
#create feature dataset CrossSectionA
addMsgAndPrint(' Creating feature data set CrossSection'+xsLetter+'...')
arcpy.CreateFeatureDataset_management(thisDB,xsName)
fieldDefs = tableDict['MapUnitPolys']
fieldDefs[0][0] = xsN+'MapUnitPolys_ID'
createFeatureClass(thisDB,xsName,xsN+'MapUnitPolys','POLYGON',fieldDefs)
fieldDefs = tableDict['ContactsAndFaults']
if addLTYPE:
fieldDefs.append(['LTYPE','String','NullsOK',50])
fieldDefs[0][0] = xsN+'ContactsAndFaults_ID'
createFeatureClass(thisDB,xsName,xsN+'ContactsAndFaults','POLYLINE',fieldDefs)
fieldDefs = tableDict['OrientationPoints']
if addLTYPE:
fieldDefs.append(['PTTYPE','String','NullsOK',50])
fieldDefs[0][0] = xsN+'OrientationPoints_ID'
createFeatureClass(thisDB,xsName,xsN+'OrientationPoints','POINT',fieldDefs)
# create tables
tables = ['DescriptionOfMapUnits','DataSources','Glossary']
for tb in ['RepurposedSymbols','StandardLithology','GeologicEvents','MiscellaneousMapInformation']:
if tb in OptionalElements:
tables.append(tb)
for table in tables:
addMsgAndPrint(' Creating table '+table+'...')
try:
arcpy.CreateTable_management(thisDB,table)
fieldDefs = tableDict[table]
for fDef in fieldDefs:
try:
if fDef[1] == 'String':
arcpy.AddField_management(thisDB+'/'+table,fDef[0],transDict[fDef[1]],'#','#',fDef[3],'#',transDict[fDef[2]])
else:
arcpy.AddField_management(thisDB+'/'+table,fDef[0],transDict[fDef[1]],'#','#','#','#',transDict[fDef[2]])
except:
addMsgAndPrint('Failed to add field '+fDef[0]+' to table '+table)
addMsgAndPrint(arcpy.GetMessages(2))
except:
addMsgAndPrint(arcpy.GetMessages())
### GeoMaterials
addMsgAndPrint(' Setting up GeoMaterials table and domains...')
# Copy GeoMaterials table
arcpy.Copy_management(os.path.dirname(sys.argv[0])+'/../Resources/GeMS_lib.gdb/GeoMaterialDict', thisDB+'/GeoMaterialDict')
# make GeoMaterials domain
arcpy.TableToDomain_management(thisDB+'/GeoMaterialDict','GeoMaterial','IndentedName',thisDB,'GeoMaterials')
# attach it to DMU field GeoMaterial
arcpy.AssignDomainToField_management(thisDB+'/DescriptionOfMapUnits','GeoMaterial','GeoMaterials')
# Make GeoMaterialConfs domain, attach it to DMU field GeoMaterialConf
arcpy.CreateDomain_management(thisDB,'GeoMaterialConfidenceValues','','TEXT','CODED')
for val in GeoMaterialConfidenceValues:
arcpy.AddCodedValueToDomain_management(thisDB,'GeoMaterialConfidenceValues',val,val)
arcpy.AssignDomainToField_management(thisDB+'/DescriptionOfMapUnits','GeoMaterialConfidence','GeoMaterialConfidenceValues')
#Confidence domains, Glossary entries, and DataSources entry
if addConfs:
addMsgAndPrint(' Adding standard ExistenceConfidence and IdentityConfidence domains')
# create domain, add domain values, and link domain to appropriate fields
addMsgAndPrint(' Creating domain, linking domain to appropriate fields')
arcpy.CreateDomain_management(thisDB,'ExIDConfidenceValues','','TEXT','CODED')
for item in DefaultExIDConfidenceValues: # items are [term, definition, source]
code = item[0]
arcpy.AddCodedValueToDomain_management(thisDB,'ExIDConfidenceValues',code,code)
arcpy.env.workspace = thisDB
dataSets = arcpy.ListDatasets()
for ds in dataSets:
arcpy.env.workspace = thisDB+'/'+ds
fcs = arcpy.ListFeatureClasses()
for fc in fcs:
fieldNames = fieldNameList(fc)
for fn in fieldNames:
if fn in ('ExistenceConfidence', 'IdentityConfidence','ScientificConfidence'):
#addMsgAndPrint(' '+ds+'/'+fc+':'+fn)
arcpy.AssignDomainToField_management(thisDB+'/'+ds+'/'+fc,fn,'ExIDConfidenceValues')
# add definitions of domain values to Glossary
addMsgAndPrint(' Adding domain values to Glossary')
## create insert cursor on Glossary
cursor = arcpy.da.InsertCursor(thisDB+'/Glossary',['Term','Definition','DefinitionSourceID'])
for item in DefaultExIDConfidenceValues:
cursor.insertRow((item[0],item[1],item[2]))
del cursor
# add definitionsource to DataSources
addMsgAndPrint(' Adding definition source to DataSources')
## create insert cursor on DataSources
cursor = arcpy.da.InsertCursor(thisDB+'/DataSources',['DataSources_ID','Source','URL'])
cursor.insertRow(('FGDC-STD-013-2006','Federal Geographic Data Committee [prepared for the Federal Geographic Data Committee by the U.S. Geological Survey], 2006, FGDC Digital Cartographic Standard for Geologic Map Symbolization: Reston, Va., Federal Geographic Data Committee Document Number FGDC-STD-013-2006, 290 p., 2 plates.','https://ngmdb.usgs.gov/fgdc_gds/geolsymstd.php'))
del cursor
# if cartoReps, add cartographic representations to all feature classes
# trackEdits, add editor tracking to all feature classes and tables
if trackEdits:
arcpy.env.workspace = thisDB
tables = arcpy.ListTables()
datasets = arcpy.ListDatasets()
for dataset in datasets:
addMsgAndPrint(' Dataset '+dataset)
arcpy.env.workspace = thisDB+'/'+dataset
fcs = arcpy.ListFeatureClasses()
for fc in fcs:
# hasReps,repLyr = cartoRepsExistAndLayer(fc)
# if cartoReps and hasReps:
# addMsgAndPrint(' Adding cartographic representations to '+fc)
# try:
# arcpy.AddRepresentation_cartography(fc,fc+'_rep1','RuleID1','Override1',default,repLyr,'NO_ASSIGN')
# """
# Note the 1 suffix on the representation name (fc+'_rep1') and the RuleID1 and Override1 fields.
# If at some later time we wish to add additional representations to a feature class, each will
# require it's own RuleID and Override fields which may be identified, and tied to the appropriate
# representation, by suffixes 2, 3, ...
# Naming representations fc+'_rep'+str(n) should be sufficient to identify each representation in a
# geodatabase uniquely, and allow for multiple representations within a single feature class.
# It appears that ArcGIS provides no means of scripting an inventory of representations within
# feature class or geodatabase. So, the convenience of establishing a coded-value domain that ties
# representation rule IDs (consecutive integers) to some sort of useful text identifier becomes a
# necessity for flagging the presence of a representation: One CAN script the inventory of domains
# in a geodatabase. Run arcpy.da.ListDomains. Check the result for names of the form
# <featureClassName>_rep??_Rule and voila, you've got a list of representations (and their associated
# feature classes) in the geodatabase.
# Moral: If you add a representation, be sure to add an associated coded-value domain and name
# it appropriately!
# """
# except:
# addMsgAndPrint(arcpy.GetMessages(2))
if trackEdits:
addTracking(fc)
if trackEdits:
addMsgAndPrint(' Tables ')
arcpy.env.workspace = thisDB
for aTable in tables:
if aTable != 'GeoMaterialDict':
addTracking(aTable)
template = r"D:\智能化管线项目\新气\新气数据处理\新气建设期转到新气数据库\new20190709gdb_hww\new20190709.gdb\Pipe_Risk"
arcpy.env.workspace = r'Database Connections\Connection to 127.0.0.1.sde'
# arcpy.env.workspace = r'D:\智能化管线项目\新气\新气数据处理\新气数据入库_0916\新库0910zlm.gdb'#r'Database Connections\Connection to 10.246.146.120.sde'#r"D:\智能化管线项目\销售华北1023数据表字段add\总部空库20180105.gdb"
arcpy.env.workspace = r'Database Connections\Connection to 10.246.146.120.sde' #r"D:\智能化管线项目\销售华北1023数据表字段add\总部空库20180105.gdb"
xlspath = r"D:\智能化管线项目\新气\新气数据处理\标准数据库-20200115.xlsx".decode('utf-8')
myworkbook = xlrd.open_workbook(xlspath)
for i in range(myworkbook.nsheets):
table = myworkbook.sheet_by_index(i) # 定位到sheet页
ncols = table.ncols
nrows = table.nrows
#全部为属性表
print myworkbook.sheet_names()[i]
arcpy.CreateTable_management(arcpy.env.workspace, table.cell(2, 0).value)
arcpy.AlterAliasName(table.cell(2, 0).value, table.cell(1, 0).value)
addfld()
#有空间表的情况
# if i == 0 or i == myworkbook.nsheets-1:
# print myworkbook.sheet_names()[i]
# # arcpy.CreateFeatureclass_management()
# arcpy.CreateFeatureclass_management("SDE.Pipe_Integrity",table.cell(2,0).value,"POLYLINE","",'ENABLED', 'DISABLED', template)
# arcpy.AlterAliasName(table.cell(2,0).value,table.cell(1,0).value)
# addfld()
# # elif i == 1:
# # arcpy.CreateFeatureclass_management("Pipe_Risk", table.cell(2, 0).value, "POLYLINE", "", 'ENABLED', 'ENABLED',
# # template)
# # arcpy.AlterAliasName(table.cell(2, 0).value, table.cell(1, 0).value)
# # addfld()
# else:
def create_gdb_table(gdb, name):
gdb_table = arcpy.CreateTable_management(gdb, name)
print("Table {} created".format(name))
return gdb_table
def WriteToFile(Walk,WalkPath):
'''
Write the random walking result to file
'''
try:
if Walk:
arcpy.AddMessage("Start to write result into files.")
env.workspace=(OutputFolder)
arcpy.env.overwriteOutput = True
'''
Insert point rvalue to point table
'''
arcpy.CreateTable_management(OutputFolder,str(PointTable)+".dbf")
arcpy.AddField_management(str(PointTable)+".dbf","NodeFID" , "SHORT")
arcpy.AddField_management(str(PointTable)+".dbf","Degree" , "SHORT")
arcpy.AddField_management(str(PointTable)+".dbf",RField , "Long")
pointrows = arcpy.InsertCursor(str(OutputFolder)+"\\"+str(PointTable)+".dbf")
for p in Net.NodeList:
pointrow = pointrows.newRow()
pointrow.setValue("NodeFID",p.ID)
pointrow.setValue("Degree",p.degree)
pointrow.setValue(RField,p.rvalue)
pointrows.insertRow(pointrow)
'''
Insert link rvalue to link table
'''
arcpy.CreateTable_management(OutputFolder,str(LinkTable)+".dbf")
arcpy.AddField_management(str(LinkTable)+".dbf","LinkFID" , "SHORT")
arcpy.AddField_management(str(LinkTable)+".dbf","Connect" , "SHORT")
arcpy.AddField_management(str(LinkTable)+".dbf",RField , "Long")
linkrows = arcpy.InsertCursor(str(OutputFolder)+"\\"+str(LinkTable)+".dbf")
for l in Net.EdgeList:
linkrow = linkrows.newRow()
linkrow.setValue("LinkFID",l.ID)
linkrow.setValue("Connect",l.connect)
linkrow.setValue(RField,l.rvalue)
linkrows.insertRow(linkrow)
'''
Export the walking path to a file
'''
sys.setrecursionlimit(1000000)
## enlarge the cursive limit
# dump walking path to a file
OutPutFiel = open(OutputFolder+"\\"+WalkPathName+".wlk","wb")
## Export the point path to a file
pickle.dump(WalkPath,OutPutFiel,2)
## dump the class into binary
OutPutFiel.close()
arcpy.AddMessage("Done!")
else:
arcpy.AddWarning("The walking calculation is failed." )
except:
# Get the traceback object
#
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
# Concatenate information together concerning the error into a message string
#
pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(sys.exc_info()[1])
msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages(2) + "\n"
# Return python error messages for use in script tool or Python Window
#
arcpy.AddError(pymsg)
arcpy.AddError(msgs)
def SLEM(Line, Distance, Output, TempFolder, TF):
CopyLine = arcpy.CopyFeatures_management(Line, "%ScratchWorkspace%\CopyLine")
fieldnames = [f.name for f in arcpy.ListFields(CopyLine)]
#/identification of the polyline type : raw, UGOs, sequenced UGOs, or AGOs
k = 0
if "Rank_AGO" in fieldnames :
k = 3
elif "Order_ID" in fieldnames :
k = 2
elif "Rank_UGO" in fieldnames :
k = 1
arcpy.AddMessage(k)
################################
########## Raw polyline ########
################################
#
if k == 0 :
#/shaping of the segmented result
arcpy.AddField_management(CopyLine, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "Rank_UGO", "!"+fieldnames[0]+"!", "PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "")
#/conversion in routes
LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure")
#/creation of the event table
PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "")
arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
UPD_SL.UpToDateShapeLengthField(LineRoutes)
rowslines = arcpy.SearchCursor(LineRoutes)
rowsevents = arcpy.InsertCursor(PointEventTEMP)
for line in rowslines:
tempdistance = float(0)
while (tempdistance < float(line.Shape_Length)):
row = rowsevents.newRow()
row.Rank_UGO = line.Rank_UGO
row.To_M = tempdistance + float(Distance)
row.Distance = tempdistance
rowsevents.insertRow(row)
tempdistance = tempdistance + float(Distance)
del rowslines
del rowsevents
#/creation of the route event layer
MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP")
Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0")
Sort = arcpy.Sort_management(Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]])
arcpy.DeleteField_management(Sort, "To_M")
#/calculation of the "Distance" field
UPD_SL.UpToDateShapeLengthField(Sort)
rows1 = arcpy.UpdateCursor(Sort)
rows2 = arcpy.UpdateCursor(Sort)
line2 = rows2.next()
line2.Distance = 0
rows2.updateRow(line2)
nrows = int(str(arcpy.GetCount_management(Sort)))
n = 0
for line1 in rows1 :
line2 = rows2.next()
if n == nrows-1 :
break
if n == 0 :
line1.Distance = 0
if line2.Rank_UGO == line1.Rank_UGO :
line2.Distance = line1.Distance + line1.Shape_Length
rows2.updateRow(line2)
if line2.Rank_UGO != line1.Rank_UGO :
line2.Distance = 0
rows2.updateRow(line2)
n+=1
#/deleting of the temporary files
if str(TF) == "true" :
arcpy.Delete_management(Split)
arcpy.Delete_management(CopyLine)
arcpy.Delete_management(LineRoutes)
arcpy.Delete_management(PointEventTEMP)
##################
###### UGO #######
##################
if k == 1 :
#/shaping of the segmented result
arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "")
#/conversion in routes
LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure")
#/creation of the event table
PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "")
arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
UPD_SL.UpToDateShapeLengthField(LineRoutes)
rowslines = arcpy.SearchCursor(LineRoutes)
rowsevents = arcpy.InsertCursor(PointEventTEMP)
for line in rowslines:
tempdistance = float(0)
while (tempdistance < float(line.Shape_Length)):
row = rowsevents.newRow()
row.Rank_UGO = line.Rank_UGO
row.To_M = tempdistance + float(Distance)
row.Distance = tempdistance
rowsevents.insertRow(row)
tempdistance = tempdistance + float(Distance)
del rowslines
del rowsevents
#/creation of the route event layer
MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP")
Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0")
Sort = arcpy.Sort_management(Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]])
arcpy.DeleteField_management(Sort, "To_M")
#/calculation of the "Distance" field
UPD_SL.UpToDateShapeLengthField(Sort)
rows1 = arcpy.UpdateCursor(Sort)
rows2 = arcpy.UpdateCursor(Sort)
line2 = rows2.next()
line2.Distance = 0
rows2.updateRow(line2)
nrows = int(str(arcpy.GetCount_management(Sort)))
n = 0
for line1 in rows1 :
line2 = rows2.next()
if n == nrows-1 :
break
if n == 0 :
line1.Distance = 0
if line2.Rank_UGO == line1.Rank_UGO :
line2.Distance = line1.Distance + line1.Shape_Length
rows2.updateRow(line2)
if line2.Rank_UGO != line1.Rank_UGO :
line2.Distance = 0
rows2.updateRow(line2)
n+=1
#/deleting of the temporary files
if str(TF) == "true" :
arcpy.Delete_management(Split)
arcpy.Delete_management(CopyLine)
arcpy.Delete_management(LineRoutes)
arcpy.Delete_management(PointEventTEMP)
################################
######### Sequenced UGO ########
################################
if k == 2 :
#/shaping of the segmented result
arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "To_Measure", "!Shape_Length!", "PYTHON_9.3", "")
#/conversion in routes
LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure")
arcpy.AddField_management(LineRoutes, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
Sort = arcpy.Sort_management(Line, "%ScratchWorkspace%\\Sort", [["Rank_UGO", "ASCENDING"]])
rows1 = arcpy.UpdateCursor(LineRoutes)
rows2 = arcpy.SearchCursor(Sort)
for line1 in rows1 :
line2 = rows2.next()
line1.Order_ID = line2.Order_ID
rows1.updateRow(line1)
#/creation of the event table
PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "")
arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
UPD_SL.UpToDateShapeLengthField(LineRoutes)
rowslines = arcpy.SearchCursor(LineRoutes)
rowsevents = arcpy.InsertCursor(PointEventTEMP)
for line in rowslines:
tempdistance = float(0)
while (tempdistance < float(line.Shape_Length)):
row = rowsevents.newRow()
row.To_M = tempdistance + float(Distance)
row.Order_ID = line.Order_ID
row.Rank_UGO = line.Rank_UGO
row.Distance = tempdistance
rowsevents.insertRow(row)
tempdistance = tempdistance + float(Distance)
del rowslines
del rowsevents
MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP")
Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0")
Sort = arcpy.Sort_management(Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]])
arcpy.DeleteField_management(Sort, "To_M")
#/calculation of the "Distance" field
UPD_SL.UpToDateShapeLengthField(Sort)
rows1 = arcpy.UpdateCursor(Sort)
rows2 = arcpy.UpdateCursor(Sort)
line2 = rows2.next()
line2.Distance = 0
rows2.updateRow(line2)
nrows = int(str(arcpy.GetCount_management(Split)))
n = 0
for line1 in rows1 :
line2 = rows2.next()
if n >= nrows-1 :
break
if n == 0 :
line1.Distance = 0
if line2.Rank_UGO == line1.Rank_UGO :
line2.Distance = line1.Distance + line1.Shape_Length
rows2.updateRow(line2)
if line2.Rank_UGO != line1.Rank_UGO :
line2.Distance = 0
rows2.updateRow(line2)
n+=1
#/deleting of the temporary files
if str(TF) == "true" :
arcpy.Delete_management(Split)
arcpy.Delete_management(CopyLine)
arcpy.Delete_management(LineRoutes)
arcpy.Delete_management(PointEventTEMP)
#############
#### AGO ####
#############
if k == 3 :
#/shaping of the segmented result
arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "PYTHON_9.3", "")
arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
try :
arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "")
except :
arcpy.CalculateField_management(CopyLine, "To_Measure", "!forme.length!", "PYTHON_9.3", "")
#/conversion in routes
LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_AGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure")
arcpy.AddField_management(LineRoutes, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(LineRoutes, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(LineRoutes, "AGO_Val", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
UPD_SL.UpToDateShapeLengthField(LineRoutes)
Ext.Export(CopyLine,TempFolder,"ExportTable")
fichier = open(TempFolder+"\\ExportTable.txt", 'r')
Order_ID = []
Rank_UGO = []
Dist = []
Rank_AGO = []
AGO_Val = []
head = fichier.readline().split('\n')[0].split(';')
iOrder_ID = head.index("Order_ID")
iRank_UGO = head.index("Rank_UGO")
iRank_AGO = head.index("Rank_AGO")
iAGO_Val = head.index("AGO_Val")
for l in fichier:
Order_ID.append(int(l.split('\n')[0].split(';')[iOrder_ID]))
Rank_UGO.append(int(l.split('\n')[0].split(';')[iRank_UGO]))
Rank_AGO.append(float(l.split('\n')[0].split(';')[iRank_AGO]))
AGO_Val.append(float(l.split('\n')[0].split(';')[iAGO_Val].replace(',','.')))
p=0
rows1 = arcpy.UpdateCursor(LineRoutes)
for line1 in rows1 :
line1.Order_ID = Order_ID[p]
line1.Rank_UGO = Rank_UGO[p]
line1.Rank_AGO = Rank_AGO[p]
line1.AGO_Val = AGO_Val[p]
rows1.updateRow(line1)
p+=1
#/creation of the event table
PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "")
arcpy.AddField_management(PointEventTEMP, "Distance_From_Start", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "Rank_AGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.AddField_management(PointEventTEMP, "AGO_Val", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
rowslines = arcpy.SearchCursor(LineRoutes)
rowsevents = arcpy.InsertCursor(PointEventTEMP)
for line in rowslines:
tempdistance = float(0)
while (tempdistance < float(line.Shape_Length)):
row = rowsevents.newRow()
row.Distance_From_Start = tempdistance
row.To_M = tempdistance + float(Distance)
row.Order_ID = line.Order_ID
row.Rank_UGO = line.Rank_UGO
row.Rank_AGO = line.Rank_AGO
row.AGO_Val = line.AGO_Val
rowsevents.insertRow(row)
tempdistance = tempdistance + float(Distance)
del rowslines
del rowsevents
MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(LineRoutes, "Rank_AGO", PointEventTEMP, "Rank_AGO LINE Distance_From_Start To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP")
Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0")
arcpy.AddField_management(Split, "Distance", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
arcpy.CalculateField_management(Split, "Distance", "!Distance_From_Start!", "PYTHON_9.3", "")
arcpy.DeleteField_management(Split, ["To_M","Distance_From_Start"])
Sort = arcpy.Sort_management(Split, Output, [["Order_ID", "ASCENDING"], ["Rank_UGO", "ASCENDING"], ["Rank_AGO", "ASCENDING"], ["Distance", "ASCENDING"]])
UPD_SL.UpToDateShapeLengthField(Sort)
#/deleting of the temporary files
if str(TF) == "true" :
arcpy.Delete_management(Split)
arcpy.Delete_management(CopyLine)
arcpy.Delete_management(LineRoutes)
arcpy.Delete_management(PointEventTEMP)
return Sort
def createTables(surveyGDB, outWorkspace, prefix):
'''Creates the doamins, tables and relationships of the survey in the target workspace'''
arcpy.AddMessage('\t-Creating Tables')
arcpy.env.workspace = surveyGDB
allTables = getSurveyTables(surveyGDB)
dscW = arcpy.Describe(arcpy.env.workspace)
#migrate the domains
arcpy.AddMessage('\t\t-Creating Domains')
for domainName in dscW.domains:
if domainName[0:3] == 'cvd':
arcpy.AddMessage('\t\t\t-'.format(domainName))
tempTable = 'in_memory\{0}'.format(domainName)
domainTable = arcpy.DomainToTable_management(surveyGDB, domainName, tempTable,'CODE', 'DESC')
newDomain = arcpy.TableToDomain_management(tempTable, 'CODE', 'DESC', outWorkspace, domainName, update_option='REPLACE')
arcpy.Delete_management(tempTable)
arcpy.AddMessage("\t\t-Creating Feature Classes & Tables")
for table in allTables:
dsc = arcpy.Describe(table)
newTableName = "{0}_{1}".format(prefix, table)
templateTable = template=os.path.join(surveyGDB, table)
if dsc.datatype == u'FeatureClass':
newTable = arcpy.CreateFeatureclass_management(outWorkspace, newTableName, "POINT", template=templateTable, spatial_reference=dsc.spatialReference)
else:
newTable = arcpy.CreateTable_management(outWorkspace, newTableName, template=templateTable)
arcpy.AddMessage("\t\t\t-Created {0}".format(newTableName))
#Attach domains to fields
tableFields = arcpy.ListFields(table)
for field in tableFields:
if field.domain != '':
arcpy.AssignDomainToField_management(newTable, field.name, field.domain)
if dscW.workspaceType == "RemoteDatabase":
arcpy.RegisterAsVersioned_management(newTable)
arcpy.AddMessage('\t\t-Creating Relationships')
#Reconnect Relationship classes, checking for attachments
CARDINALITIES = {
'OneToOne': "ONE_TO_ONE",
'OneToMany': "ONE_TO_MANY",
'ManyToMany': "MANY_TO_MANY"
}
for child in [(c.name, c.datatype) for c in dscW.children if c.datatype == u'RelationshipClass']:
dscRC = arcpy.Describe(child[0])
RCOriginTable = dscRC.originClassNames[0]
RCDestTable = dscRC.destinationClassNames[0]
newOriginTable = "{0}_{1}".format(prefix, RCOriginTable)
newOriginPath = os.path.join(outWorkspace, newOriginTable)
if dscRC.isAttachmentRelationship:
#Simple case - attachments have a dedicated tool
arcpy.EnableAttachments_management(newOriginPath)
else:
newDestTable = "{0}_{1}".format(prefix, RCDestTable)
newDestPath = os.path.join(outWorkspace, newDestTable)
newRC = os.path.join(outWorkspace, "{0}_{1}".format(prefix, child[0]))
relationshipType = "COMPOSITE" if dscRC.isComposite else "SIMPLE"
fwd_label = dscRC.forwardPathLabel if dscRC.forwardPathLabel != '' else 'Repeat'
bck_label = dscRC.backwardPathLabel if dscRC.backwardPathLabel != '' else 'MainForm'
msg_dir = dscRC.notification.upper()
cardinality = CARDINALITIES[dscRC.cardinality]
attributed = "ATTRIBUTED" if dscRC.isAttributed else "NONE"
originclassKeys = dscRC.originClassKeys
originclassKeys_dict = {}
for key in originclassKeys:
originclassKeys_dict[key[1]] = key[0]
originPrimaryKey = originclassKeys_dict[u'OriginPrimary']
originForiegnKey = originclassKeys_dict[u'OriginForeign']
arcpy.CreateRelationshipClass_management(newOriginPath, newDestPath, newRC, relationshipType, fwd_label, bck_label, msg_dir, cardinality, attributed, originPrimaryKey, originForiegnKey)
# Remove invalid keys from master list
i = 0
while i < len(crashKey):
if crashKey[i] not in validKey:
crashKey.pop(i)
else:
i += 1
# Check if any crashes were selected before continuing
if not crashKey:
arcpy.AddMessage('ERROR! No crashes were selected! The script will now terminate.')
quit()
# Create table for selected crashes
arcpy.CreateTable_management('in_memory', 'crash')
arcpy.AddField_management('in_memory/crash', 'CRASH_KEY', 'DOUBLE',11,0)
crashKeyTable = 'in_memory/crash'
crashCursor = arcpy.InsertCursor(crashKeyTable)
for key in crashKey: # Loop through list of CRASH_KEYs and place key in table
record = crashCursor.newRow()
record.CRASH_KEY = key
crashCursor.insertRow(record)
# Create project folder
arcpy.AddMessage('\nCreating project folder...')
arcpy.CreateFolder_management(PROJECT_FOLDER, projectNumber + '-' + projectName.replace(' ', '_'))
arcpy.AddMessage('done!')
# Set project folder variable
header = updated_route_system[0][0]
header_updated = updated_route_system[0][1]
arcpy.AddMessage('-- ' + header + '...')
arcpy.TruncateTable_management(header)
arcpy.Delete_management(header)
arcpy.CopyFeatures_management(header_updated, header)
arcpy.Delete_management(header_updated)
# Itinerary table:
itin = updated_route_system[1][0]
itin_updated = updated_route_system[1][1]
arcpy.AddMessage('-- ' + itin + '...')
arcpy.TruncateTable_management(itin)
arcpy.Delete_management(itin)
itin_path = MHN.break_path(itin)
# CreateTable & Append because CopyFeatures crashes randomly with large tables.
arcpy.CreateTable_management(itin_path['dir'], itin_path['name'],
itin_updated)
arcpy.Append_management(itin_updated, itin, 'TEST')
arcpy.Delete_management(itin_updated)
# Replace old nodes.
arcpy.AddMessage('-- ' + MHN.node + '...')
arcpy.Delete_management(MHN.node)
arcpy.CopyFeatures_management(new_nodes_CZ, MHN.node)
arcpy.Delete_management(new_nodes_CZ)
# Replace old arcs.
arcpy.AddMessage('-- ' + MHN.arc + '...')
arcpy.Delete_management(MHN.arc)
arcpy.CopyFeatures_management(temp_arcs, MHN.arc)
arcpy.Delete_management(temp_arcs)
def execute(self, parameters, messages):
positives_param, negatives_param, models_param, output_param = parameters
arcpy.env.workspace = output_param.valueAsText
positives_descr = arcpy.Describe(positives_param.valueAsText)
positives_x, positives_y = FetchCoordinates(positives_descr.catalogPath).T
positives_sref = positives_descr.spatialReference
if negatives_param.valueAsText:
negatives_descr = arcpy.Describe(negatives_param.valueAsText)
negatives_sref = positives_descr.spatialReference
if not SpatialReferencesAreEqual(positives_sref, negatives_sref,
messages):
raise ValueError(
"Positives and negatives have different spatial references: '%s' and '%s'."
% (positives_sref.name, negatives_sref.name))
else:
negatives_descr = None
pylab.figure()
handle, = pylab.plot([0, 1], [0, 1], "k--", lw=2)
legend_items = ["Random guess"]
plot_handles = [handle]
# Iterates through each model and calculates and plots ROC curves for them.
max_rows = 0
model_names, roc_curves, auc_values, auc_confints = [], [], [], []
tokens = models_param.valueAsText.split(";")
for i in range(len(tokens)):
raster_descr = arcpy.Describe(tokens[i])
raster_sref = raster_descr.spatialReference
if not SpatialReferencesAreEqual(positives_sref, raster_sref,
messages):
raise ValueError(
"Positives and %s have different spatial references: '%s' and '%s'."
% (raster_descr.name, positives_sref.name, raster_sref.name))
color = COLOR_TABLE[i % NUM_COLORS]
_roc_curve, _roc_confints, _auc_value, _auc_confints = CalculateROCCurveAndAUCValueForModel(
messages, raster_descr, negatives_descr, positives_x, positives_y)
if _roc_confints:
pylab.fill_between(_roc_confints[0][:, 0],
_roc_confints[0][:, 1],
_roc_confints[1][:, 1],
color=color,
alpha=0.1)
handle, = pylab.plot(_roc_curve[:, 0],
_roc_curve[:, 1],
lw=2,
color=color)
plot_handles.append(handle)
legend_items.append("%s (AUC = %.3f)" %
(raster_descr.name, _auc_value))
messages.addMessage("%s: AUC = %.3f." %
(raster_descr.name, _auc_value))
if _auc_confints:
messages.addMessage(
"%s: 95%% confidence interval = %.3f-%.3f." %
(raster_descr.name, _auc_confints[0], _auc_confints[1]))
model_names.append(raster_descr.name)
roc_curves.append(_roc_curve)
auc_values.append(_auc_value)
auc_confints.append(_auc_confints)
max_rows = numpy.max([max_rows, len(_roc_curve)])
# Configures the plot and saves it.
png_path = arcpy.CreateUniqueName("results.png")
pylab.gca().set_xlim([0, 1])
pylab.gca().set_ylim([0, 1])
pylab.xlabel("False Positive Rate")
pylab.ylabel("True Positive Rate")
pylab.legend(plot_handles, legend_items, 4)
pylab.savefig(png_path)
messages.addMessage("Saved ROC curve plot to '%s'." % png_path)
# Creates a database table for storing the essential results.
table_path = arcpy.CreateUniqueName("results.dbf")
dbf_path, dbf_name = os.path.split(table_path)
arcpy.CreateTable_management(dbf_path, dbf_name)
arcpy.AddField_management(table_path, "MODEL", "TEXT", field_length=10)
arcpy.AddField_management(table_path, "AUC", "TEXT", field_length=10)
if not negatives_descr:
arcpy.AddField_management(table_path,
"AUC_LO",
"TEXT",
field_length=10)
arcpy.AddField_management(table_path,
"AUC_HI",
"TEXT",
field_length=10)
for i in range(len(model_names)):
arcpy.AddField_management(table_path,
"FPR_%d" % (i + 1),
"DOUBLE",
20,
10,
field_length=10)
arcpy.AddField_management(table_path,
"TPR_%d" % (i + 1),
"DOUBLE",
20,
10,
field_length=10)
arcpy.DeleteField_management(table_path,
"Field1") # Deletes a nuisance field!?
# Populates the database table.
cursor = arcpy.InsertCursor(table_path)
for i in range(max_rows):
row = cursor.newRow()
if i < len(model_names):
row.setValue("MODEL", model_names[i])
row.setValue("AUC", "%.3f" % auc_values[i])
if not negatives_descr:
row.setValue("AUC_LO", "%.3f" % auc_confints[i][0])
row.setValue("AUC_HI", "%.3f" % auc_confints[i][1])
for j in range(len(model_names)):
if len(roc_curves[j]) > i:
row.setValue("FPR_%d" % (j + 1), roc_curves[j][i, 0])
row.setValue("TPR_%d" % (j + 1), roc_curves[j][i, 1])
cursor.insertRow(row)
del cursor, row
messages.addMessage("Saved results database table to '%s'." % table_path)
def update_route_system(header,
itin,
vertices_comprising,
split_dict_ABB,
new_ABB_values,
common_id_field,
order_field=None):
''' A method for updating any of the MHN's route systems: hwyproj,
bus_base, bus_current, and bus_future. order_field argument allows for
separate treatment of hwyproj and the bus routes. '''
# Copy itinerary table to memory for non-destructive editing
header_name = MHN.break_path(header)['name']
itin_name = MHN.break_path(itin)['name']
arcpy.AddMessage('-- ' + header_name + '...')
itin_copy_path = MHN.mem
itin_copy_name = itin_name + '_copy'
itin_copy = os.path.join(itin_copy_path, itin_copy_name)
arcpy.CreateTable_management(itin_copy_path, itin_copy_name, itin)
itin_OID_field = MHN.determine_OID_fieldname(itin)
itin_dict = MHN.make_attribute_dict(itin, itin_OID_field)
# Check validity of ABB value on each line, adjusting the itinerary when
# invalidity is due to a split
max_itin_OID = max([OID for OID in itin_dict])
split_itin_dict = {}
all_itin_OIDs = list(itin_dict.keys())
all_itin_OIDs.sort(
) # For processing in itinerary order, rather than in the dict's pseudo-random order
bad_itin_OIDs = []
if order_field:
order_bump = 0
for OID in all_itin_OIDs:
common_id = itin_dict[OID][common_id_field]
if order_field:
order = itin_dict[OID][order_field]
if order == 1:
order_bump = 0
ABB = itin_dict[OID]['ABB']
if ABB != None:
anode = int(ABB.split('-')[0])
bnode = int(ABB.split('-')[1])
baselink = int(ABB.split('-')[2])
else:
anode = 0
bnode = 0
baselink = 0
if ABB not in new_ABB_values:
if not order_field: # For hwyproj, all deleted links should be removed from coding. Split links will be replaced.
bad_itin_OIDs.append(OID)
if (
anode, bnode, baselink
) in split_dict_ABB: # If ABB is invalid because it was split, find new ABB values
ordered_segments = split_dict_ABB[(anode, bnode, baselink)]
if order_field:
bad_itin_OIDs.append(
OID
) # For bus routes, only split links should be removed (and replaced).
itin_a = itin_dict[OID]['ITIN_A']
itin_b = itin_dict[OID]['ITIN_B']
if itin_b == anode or itin_a == bnode:
backwards = True
ordered_segments = ordered_segments[::
-1] # Make a reversed copy of the ordered segments
else:
backwards = False
for split_ABB in ordered_segments:
split_anode = int(split_ABB[0].split('-')[0])
split_bnode = int(split_ABB[0].split('-')[1])
split_baselink = int(split_ABB[0].split('-')[2])
split_length_ratio = split_ABB[3]
max_itin_OID += 1
split_itin_dict[max_itin_OID] = itin_dict[OID].copy()
split_itin_dict[max_itin_OID]['ABB'] = split_ABB[0]
if order_field:
if backwards:
split_itin_a = split_bnode
split_itin_b = split_anode
split_start_ratio = 1 - (split_ABB[2] +
split_length_ratio)
else:
split_itin_a = split_anode
split_itin_b = split_bnode
split_start_ratio = split_ABB[2]
# Adjust itinerary nodes and order:
split_itin_dict[max_itin_OID]['ITIN_A'] = split_itin_a
split_itin_dict[max_itin_OID]['ITIN_B'] = split_itin_b
if split_itin_a != itin_a: # First split segment receives the same order as the original
order_bump += 1
split_itin_dict[max_itin_OID][
order_field] += order_bump
# Adjust variables that only apply to original link's itin_b:
if split_itin_dict[max_itin_OID][
'LAYOVER'] > 0 and split_itin_b != itin_b:
split_itin_dict[max_itin_OID]['LAYOVER'] = 0
# Apportion length-dependent variables:
split_itin_dict[max_itin_OID][
'LINE_SERV_TIME'] *= split_length_ratio
F_MEAS = split_itin_dict[max_itin_OID]['F_MEAS']
T_MEAS = split_itin_dict[max_itin_OID]['T_MEAS']
meas_diff = T_MEAS - F_MEAS
if header_name == 'bus_future':
future = True
else:
future = False
if not future: # bus_future has no DEP_TIME or ARR_TIME
DEP_TIME = split_itin_dict[max_itin_OID][
'DEP_TIME']
ARR_TIME = split_itin_dict[max_itin_OID][
'ARR_TIME']
time_diff = ARR_TIME - DEP_TIME
if split_itin_a != itin_a:
split_itin_dict[max_itin_OID][
'F_MEAS'] += meas_diff * split_start_ratio
if not future:
split_itin_dict[max_itin_OID][
'DEP_TIME'] += time_diff * split_start_ratio
else:
pass # F_MEAS & DEP_TIME are already correct for itin_a
if split_itin_b != itin_b:
split_itin_dict[max_itin_OID][
'T_MEAS'] = F_MEAS + meas_diff * (
split_start_ratio + split_length_ratio)
if not future:
split_itin_dict[max_itin_OID][
'ARR_TIME'] = DEP_TIME + time_diff * (
split_start_ratio + split_length_ratio)
else:
pass # T_MEAS & ARR_TIME are already correct for itin_b
else:
if order_field:
itin_dict[OID][order_field] += order_bump
for OID in bad_itin_OIDs:
del itin_dict[
OID] # Remove invalid ABB records after accounting for splits
# Combine itinerary dicts, adjust ITIN_ORDER and report new gaps and write
# updated records to table in memory.
itin_dict.update(split_itin_dict)
itin_fields = [
field.name for field in arcpy.ListFields(itin_copy)
if field.type != 'OID'
]
with arcpy.da.InsertCursor(itin_copy, itin_fields) as coding_cursor:
for OID in itin_dict:
coding_cursor.insertRow(
[itin_dict[OID][field] for field in itin_fields])
# Sort records into a second table in memory.
itin_updated = os.path.join(MHN.mem,
'{0}_itin_updated'.format(header_name))
if order_field:
arcpy.Sort_management(
itin_copy, itin_updated,
[[common_id_field, 'ASCENDING'], [order_field, 'ASCENDING']])
else:
arcpy.Sort_management(itin_copy, itin_updated,
[[common_id_field, 'ASCENDING']])
arcpy.Delete_management(itin_copy)
# Re-build line features.
header_updated_path = MHN.mem
header_updated_name = '{0}_updated'.format(header_name)
header_updated = os.path.join(header_updated_path, header_updated_name)
arcs_traversed_by = {}
field_list = ['ABB', common_id_field]
with arcpy.da.SearchCursor(itin_updated, field_list) as itin_cursor:
for row in itin_cursor:
abb = row[0]
common_id = row[1]
if common_id in arcs_traversed_by:
arcs_traversed_by[common_id].append(abb)
else:
arcs_traversed_by[common_id] = [abb]
common_id_list = [
row[0] for row in arcpy.da.SearchCursor(header, [common_id_field])
]
arcpy.CreateFeatureclass_management(header_updated_path,
header_updated_name, 'POLYLINE',
header)
with arcpy.da.InsertCursor(header_updated,
['SHAPE@', common_id_field]) as routes_cursor:
for common_id in common_id_list:
route_vertices = arcpy.Array([
vertices_comprising[abb]
for abb in arcs_traversed_by[common_id]
if abb in vertices_comprising
])
try:
route = arcpy.Polyline(route_vertices)
routes_cursor.insertRow([route, common_id])
except:
itin_delete_query = ''' "{0}" = '{1}' '''.format(
common_id_field, common_id)
with arcpy.da.UpdateCursor(
itin_updated, ['OID@'],
itin_delete_query) as itin_delete_cursor:
for row in itin_delete_cursor:
itin_delete_cursor.deleteRow()
arcpy.AddWarning(
' - {0} = {1} cannot be rebuilt because the arcs comprising '
'it no longer exist (or have new ABB). It cannot be rebuilt '
'and is being deleted. Please re-import it if necessary.'.
format(common_id_field, common_id))
# Append the header file attribute values from a search cursor of the original.
attributes = MHN.make_attribute_dict(header, common_id_field)
update_fields = [
field.name for field in arcpy.ListFields(header)
if field.type not in ['OID', 'Geometry']
and field.name.upper() != 'SHAPE_LENGTH'
]
with arcpy.da.UpdateCursor(header_updated,
update_fields) as attribute_cursor:
for row in attribute_cursor:
common_id = row[update_fields.index(common_id_field)]
for field in [
field for field in update_fields
if field != common_id_field
]:
row[update_fields.index(field)] = attributes[common_id][field]
attribute_cursor.updateRow(row)
return ((header, header_updated), (itin, itin_updated))
def add_to_geodatabase(input_items, out_gdb, is_fds):
"""Adds items to a geodatabase."""
added = 0
skipped = 0
errors = 0
global processed_count
global layer_name
global existing_fields
global new_fields
global field_values
for ds, out_name in input_items.iteritems():
try:
# -----------------------------------------------
# If the item is a service layer, process and continue.
# -----------------------------------------------
if ds.startswith('http'):
try:
service_layer = task_utils.ServiceLayer(ds)
arcpy.env.overwriteOutput = True
oid_groups = service_layer.object_ids
out_features = None
g = 0.
group_cnt = service_layer.object_ids_cnt
for group in oid_groups:
g += 1
group = [oid for oid in group if oid]
where = '{0} IN {1}'.format(service_layer.oid_field_name, tuple(group))
url = ds + "/query?where={}&outFields={}&returnGeometry=true&geometryType=esriGeometryPolygon&f=json".format(where, '*')
feature_set = arcpy.FeatureSet()
feature_set.load(url)
if not out_features:
out_features = arcpy.CopyFeatures_management(feature_set, task_utils.create_unique_name(out_name, out_gdb))
else:
features = arcpy.CopyFeatures_management(feature_set, task_utils.create_unique_name(out_name, out_gdb))
arcpy.Append_management(features, out_features, 'NO_TEST')
try:
arcpy.Delete_management(features)
except arcpy.ExecuteError:
pass
status_writer.send_percent(float(g) / group_cnt * 100, '', 'add_to_geodatabase')
processed_count += 1.
added += 1
status_writer.send_percent(processed_count / result_count, _('Added: {0}').format(ds), 'add_to_geodatabase')
continue
except Exception as ex:
status_writer.send_state(status.STAT_WARNING, str(ex))
errors_reasons[ds] = ex.message
errors += 1
continue
# ------------------------------
# Is the input a mxd data frame.
# ------------------------------
map_frame_name = task_utils.get_data_frame_name(ds)
if map_frame_name:
ds = ds.split('|')[0].strip()
# -------------------------------
# Is the input a geometry feature
# -------------------------------
if isinstance(out_name, list):
increment = task_utils.get_increment(result_count)
for row in out_name:
try:
name = os.path.join(out_gdb, arcpy.ValidateTableName(ds, out_gdb))
# Create the geometry if it exists.
geom = None
try:
geo_json = row['[geo]']
geom = arcpy.AsShape(geo_json)
row.pop('[geo]')
except KeyError:
pass
if geom:
if not arcpy.Exists(name):
if arcpy.env.outputCoordinateSystem:
arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper())
else:
arcpy.env.outputCoordinateSystem = 4326
arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper())
layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer_{0}'.format(os.path.basename(name)))
existing_fields = [f.name for f in arcpy.ListFields(layer_name)]
new_fields = []
field_values = []
for field, value in row.iteritems():
valid_field = arcpy.ValidateFieldName(field, out_gdb)
new_fields.append(valid_field)
field_values.append(value)
arcpy.AddField_management(layer_name, valid_field, 'TEXT')
else:
if not geom.type.upper() == arcpy.Describe(name).shapeType.upper():
name = arcpy.CreateUniqueName(os.path.basename(name), out_gdb)
if arcpy.env.outputCoordinateSystem:
arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper())
else:
arcpy.env.outputCoordinateSystem = 4326
arcpy.CreateFeatureclass_management(out_gdb, os.path.basename(name), geom.type.upper())
layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer_{0}'.format(os.path.basename(name)))
existing_fields = [f.name for f in arcpy.ListFields(layer_name)]
new_fields = []
field_values = []
for field, value in row.iteritems():
valid_field = arcpy.ValidateFieldName(field, out_gdb)
new_fields.append(valid_field)
field_values.append(value)
if valid_field not in existing_fields:
arcpy.AddField_management(layer_name, valid_field, 'TEXT')
else:
if not arcpy.Exists(name):
arcpy.CreateTable_management(out_gdb, os.path.basename(name))
view_name = arcpy.MakeTableView_management(name, 'tableview')
existing_fields = [f.name for f in arcpy.ListFields(view_name)]
new_fields = []
field_values = []
for field, value in row.iteritems():
valid_field = arcpy.ValidateFieldName(field, out_gdb)
new_fields.append(valid_field)
field_values.append(value)
if valid_field not in existing_fields:
arcpy.AddField_management(view_name, valid_field, 'TEXT')
if geom:
with arcpy.da.InsertCursor(layer_name, ["SHAPE@"] + new_fields) as icur:
icur.insertRow([geom] + field_values)
else:
with arcpy.da.InsertCursor(view_name, new_fields) as icur:
icur.insertRow(field_values)
processed_count += 1
if (processed_count % increment) == 0:
status_writer.send_percent(float(processed_count) / result_count, _('Added: {0}').format(row['name']), 'add_to_geodatabase')
added += 1
continue
except Exception as ex:
processed_count += 1
errors += 1
errors_reasons[name] = ex.message
continue
continue
# -----------------------------
# Check the data type and clip.
# -----------------------------
dsc = arcpy.Describe(ds)
if dsc.dataType == 'FeatureClass':
if out_name == '':
arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(dsc.name, out_gdb))
else:
arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(out_name, out_gdb))
elif dsc.dataType == 'ShapeFile':
if out_name == '':
arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(dsc.name[:-4], out_gdb))
else:
arcpy.CopyFeatures_management(ds, task_utils.create_unique_name(out_name, out_gdb))
elif dsc.dataType == 'FeatureDataset':
if not is_fds:
fds_name = os.path.basename(task_utils.create_unique_name(dsc.name, out_gdb))
fds = arcpy.CreateFeatureDataset_management(out_gdb, fds_name).getOutput(0)
else:
fds = out_gdb
arcpy.env.workspace = dsc.catalogPath
for fc in arcpy.ListFeatureClasses():
name = os.path.basename(task_utils.create_unique_name(fc, out_gdb))
arcpy.CopyFeatures_management(fc, os.path.join(fds, name))
arcpy.env.workspace = out_gdb
elif dsc.dataType == 'RasterDataset':
if is_fds:
out_gdb = os.path.dirname(out_gdb)
if out_name == '':
arcpy.CopyRaster_management(ds, task_utils.create_unique_name(dsc.name, out_gdb))
else:
arcpy.CopyRaster_management(ds, task_utils.create_unique_name(out_name, out_gdb))
elif dsc.dataType == 'RasterCatalog':
if is_fds:
out_gdb = os.path.dirname(out_gdb)
if out_name == '':
arcpy.CopyRasterCatalogItems_management(ds, task_utils.create_unique_name(dsc.name, out_gdb))
else:
arcpy.CopyRasterCatalogItems_management(ds, task_utils.create_unique_name(out_name, out_gdb))
elif dsc.dataType == 'Layer':
layer_from_file = arcpy.mapping.Layer(dsc.catalogPath)
layers = arcpy.mapping.ListLayers(layer_from_file)
for layer in layers:
if out_name == '':
name = task_utils.create_unique_name(layer.name, out_gdb)
else:
name = task_utils.create_unique_name(out_name, out_gdb)
if layer.isFeatureLayer:
arcpy.CopyFeatures_management(layer.dataSource, name)
elif layer.isRasterLayer:
if is_fds:
name = os.path.dirname(name)
arcpy.CopyRaster_management(layer.dataSource, name)
elif dsc.dataType == 'CadDrawingDataset':
arcpy.env.workspace = dsc.catalogPath
cad_wks_name = os.path.splitext(dsc.name)[0]
for cad_fc in arcpy.ListFeatureClasses():
arcpy.CopyFeatures_management(
cad_fc,
task_utils.create_unique_name('{0}_{1}'.format(cad_wks_name, cad_fc), out_gdb)
)
arcpy.env.workspace = out_gdb
elif dsc.dataType == 'File':
if dsc.catalogPath.endswith('.kml') or dsc.catalogPath.endswith('.kmz'):
name = os.path.splitext(dsc.name)[0]
temp_dir = tempfile.mkdtemp()
kml_layer = arcpy.KMLToLayer_conversion(dsc.catalogPath, temp_dir, name)
group_layer = arcpy.mapping.Layer(os.path.join(temp_dir, '{}.lyr'.format(name)))
for layer in arcpy.mapping.ListLayers(group_layer):
if layer.isFeatureLayer:
arcpy.CopyFeatures_management(layer, task_utils.create_unique_name(layer, out_gdb))
elif layer.isRasterLayer:
if is_fds:
out_gdb = os.path.dirname(out_gdb)
arcpy.CopyRaster_management(layer, task_utils.create_unique_name(layer, out_gdb))
# Clean up temp KML results.
arcpy.Delete_management(os.path.join(temp_dir, '{}.lyr'.format(name)))
arcpy.Delete_management(kml_layer)
else:
processed_count += 1
status_writer.send_percent(processed_count / result_count, _('Invalid input type: {0}').format(dsc.name), 'add_to_geodatabase')
skipped += 1
skipped_reasons[ds] = _('Invalid input type: {0}').format(dsc.dataType)
continue
elif dsc.dataType == 'MapDocument':
mxd = arcpy.mapping.MapDocument(dsc.catalogPath)
if map_frame_name:
df = arcpy.mapping.ListDataFrames(mxd, map_frame_name)[0]
layers = arcpy.mapping.ListLayers(mxd, data_frame=df)
else:
layers = arcpy.mapping.ListLayers(mxd)
for layer in layers:
if layer.isFeatureLayer:
arcpy.CopyFeatures_management(layer.dataSource,
task_utils.create_unique_name(layer.name, out_gdb))
elif layer.isRasterLayer:
if is_fds:
out_gdb = os.path.dirname(out_gdb)
arcpy.CopyRaster_management(layer.dataSource,
task_utils.create_unique_name(layer.name, out_gdb))
table_views = arcpy.mapping.ListTableViews(mxd)
if is_fds:
out_gdb = os.path.dirname(out_gdb)
for table_view in table_views:
arcpy.CopyRows_management(table_view.dataSource,
task_utils.create_unique_name(table_view.name, out_gdb))
out_gdb = arcpy.env.workspace
elif dsc.dataType.find('Table') > 0:
if is_fds:
out_gdb = os.path.dirname(out_gdb)
if out_name == '':
arcpy.CopyRows_management(ds, task_utils.create_unique_name(dsc.name, out_gdb))
else:
arcpy.CopyRows_management(ds, task_utils.create_unique_name(out_name, out_gdb))
else:
# Try to copy any other types such as topologies, network datasets, etc.
if is_fds:
out_gdb = os.path.dirname(out_gdb)
arcpy.Copy_management(ds, task_utils.create_unique_name(dsc.name, out_gdb))
out_gdb = arcpy.env.workspace
processed_count += 1.
status_writer.send_percent(processed_count / result_count, _('Added: {0}').format(ds), 'add_to_geodatabase')
status_writer.send_status(_('Added: {0}').format(ds))
added += 1
# Continue if an error. Process as many as possible.
except Exception as ex:
processed_count += 1
status_writer.send_percent(processed_count / result_count, _('Skipped: {0}').format(ds), 'add_to_geodatabase')
status_writer.send_status(_('FAIL: {0}').format(repr(ex)))
errors_reasons[ds] = repr(ex)
errors += 1
continue
return added, errors, skipped
arcpy.AddGeometryAttributes_management("notakeall_diss_project","AREA_GEODESIC","","SQUARE_KILOMETERS",in_mollweideprj)
arcpy.Statistics_analysis("notakeall_diss_project","sum_NOTAKEall",[["AREA_GEO","SUM"]])
arcpy.Select_analysis("all_wdpa_polybuffpnt", r"in_memory\notake_part","NO_TAKE = 'Part'")
arcpy.Statistics_analysis(r"in_memory\notake_part","sum_NOTAKEpart",[["NO_TK_AREA","SUM"]])
elapsed_hours = (time.clock() - start)/3600
print(("Stage 1 took " + str(elapsed_hours) + " hours"))
##-------------------------------------------------------------------------------------------------------------------------
#Stage 2: National and National PAME analysis
print ("Stage 2 of 2: National & National PAME Analyses")
# create the summary tables for appending in individual natioanl summary statistics
out_national_current_schema = arcpy.CreateTable_management(workspace,"out_national_current_schema")
arcpy.AddFields_management(out_national_current_schema,[['WDPA_ISO3','TEXT'],['type','TEXT'],['FREQUENCY','LONG'],['SUM_AREA_GEO','DOUBLE']])
out_national_temporal_schema = arcpy.CreateTable_management(workspace,"out_national_temporal_schema")
arcpy.AddFields_management(out_national_temporal_schema,[['WDPA_ISO3','TEXT'],['MIN_STATUS_YR','DOUBLE'],['type','TEXT'],['FREQUENCY','LONG'],['SUM_AREA_GEO','DOUBLE']])
out_national_current_schema_pame = arcpy.CreateTable_management(workspace,"out_national_current_schema_pame")
arcpy.AddFields_management(out_national_current_schema_pame,[['WDPA_ISO3','TEXT'],['type','TEXT'],['FREQUENCY','LONG'],['SUM_AREA_GEO','DOUBLE']])
out_national_temporal_schema_pame = arcpy.CreateTable_management(workspace,"out_national_temporal_schema_pame")
arcpy.AddFields_management(out_national_temporal_schema_pame,[['WDPA_ISO3','TEXT'],['MIN_STATUS_YR','DOUBLE'],['type','TEXT'],['FREQUENCY','LONG'],['SUM_AREA_GEO','DOUBLE']])
# join pame list to polybuffpnt
arcpy.JoinField_management("all_wdpa_polybuffpnt","WDPAID",in_pame_sites,"wdpa_id","evaluation_id")
# update field (0) for those that don't have id
