def summarize_crashes(buffs,
out_features=arcpy.CreateUniqueName(
'crash_summary', 'in_memory'),
crash_service_url=DEFAULT_CRASH_URL):
"""downloads and summarizes crash information within buffered intersections
Required:
buffs -- intersection buffers
out_features -- output features
crash_service_url -- IOWA DOT Crash REST Service url
"""
# dissolve buffers for REST API query
dis = arcpy.CreateUniqueName('buff_dis', 'in_memory')
arcpy.management.Dissolve(buffs, dis)
# custom module: get layer from REST service
lyr = restapi.MapServiceLayer(crash_service_url)
# get geometry as JSON
g = restapi.Geometry(dis)
# query REST Service
fs = lyr.query(geometry=g)
crashes = arcpy.CreateUniqueName('crashes', 'in_memory')
# export feature set
restapi.exportFeatureSet(fs, crashes)
# crash summary fields
crash_sum_fields = [
'FATALITIES', 'INJURIES', 'MAJINJURY', 'MININJURY', 'POSSINJURY',
'UNKINJURY', 'PROPDMG', 'VEHICLES', 'TOCCUPANTS'
]
# create field map for spatial join
fms = arcpy.FieldMappings()
fms.addTable(buffs)
fms.addTable(crashes)
# set field map merge option to 'Sum' to summarize crash results per intersection buffer
for field_name in crash_sum_fields:
fi = fms.findFieldMapIndex(field_name)
field = fms.getFieldMap(fi)
field.mergeRule = 'Sum'
# update field map
fms.replaceFieldMap(fi, field)
# do spatial join
arcpy.analysis.SpatialJoin(buffs, crashes, out_features, field_mapping=fms)
return out_features
def create_unique_name(name, gdb):
"""Creates and returns a valid and unique name for the geodatabase.
:param name: name to be validated
:param gdb: workspace path
:rtype : str
"""
import arcpy
if gdb.endswith('.gdb'):
valid_name = arcpy.ValidateTableName(name, gdb)
unique_name = arcpy.CreateUniqueName(valid_name, gdb)
else:
valid_name = arcpy.ValidateTableName(name, gdb)
unique_name = arcpy.CreateUniqueName(valid_name + '.shp', gdb)
return unique_name
def publish_service(service_name, results):
"""Publishes the results list to an ArcGIS Server specified in the config module"""
# Create Service draft.
sddraft = arcpy.CreateUniqueName(service_name + '.sddraft')
info = arcpy.CreateGPSDDraft(results,
sddraft,
service_name,
folder_name=ARC_SERVER['serviceFolder'],
showMessages='INFO')
sd = arcpy.CreateUniqueName(service_name + '.sd')
info = arcpy.StageService_server(sddraft, sd)
info = arcpy.UploadServiceDefinition_server(sd, ARC_SERVER['uri'])
return sd
def generate_gdb_filename(name_base="xt",
return_full=True,
gdb=None,
scratch=False):
'''returns the filename and the gdb separately for use in some tools'''
if gdb is None:
temp_gdb = get_temp_gdb()
else:
temp_gdb = gdb
try:
if scratch:
filename = arcpy.CreateScratchName(name_base, workspace=temp_gdb)
else:
filename = arcpy.CreateUniqueName(name_base, temp_gdb)
except:
geoprocessing_log.error("Couldn't create GDB filename - {0:s}".format(
traceback.format_exc()))
raise
temp_datasets.append(filename) # add it to the tempfile registry
if return_full:
return filename
else:
return os.path.split(filename)[1], temp_gdb
def __init__(self,
remote_assets,
fixed_assets,
near_table,
closest_facility,
folder,
search_threshold=MAX_SEARCH,
daisy_threshold=MAX_DAISY,
extend_route=False):
self.remote = remote_assets
self.fixed = fixed_assets
self.near = near_table
self.CF = common.wrappers.ClosestFacilityHelper(closest_facility)
self.search = search_threshold
self.daisy = daisy_threshold
self.extend = extend_route
self.gdb = arcpy.CreateUniqueName(FINAL_GDB, folder)
self.field_map = arcpy.na.NAClassFieldMappings(
network_analyst_layer=self.CF.na_layer,
sub_layer_name=self.CF.facilities.name,
use_location_fields=True,
list_candidate_fields=arcpy.ListFields(self.remote))
self.result = None
self.route_fields = None
self.near_array = None
self.point_dict = None
self.fixed_assets = []
def intersectar(fcCarto,
fcPlanif,
scrWS,
cfecha="FCH_TRAN",
chas="AREA",
cPctje="PCT_AVANCE",
calcHcarto=True,
calcHplanif=True,
calcP=True):
#-------------------------------------------------------------------------------------------------------------------------
if calcHcarto:
agregarHAS(fcCarto, chas)
if calcHplanif:
agregarHAS(fcPlanif, chas)
oldWS = arcpy.env.workspace
arcpy.env.workspace = scrWS
salida = arcpy.CreateUniqueName("Intersect")
print(salida)
arcpy.Intersect_analysis([fcCarto, fcPlanif], salida, "ALL", eps, "INPUT")
agregarHAS(salida, "HAS")
if calcP:
agregarPCTJE(salida, "HAS", cPctje, "AREA_1")
agregarCampos(salida, cfecha)
arcpy.env.workspace = oldWS
return (corto(salida))
def execute(in_netcdf, out_feat, levels=(20, 25, 30, 35, 40, 45), mask=None):
# This is a very stupid fix for multiprocessing
# But I am sure why arcpy.CheckoutExtension works
arcpy.env.overwriteOutput = True
arcpy.env.workspace = "in_memory"
workspace = "in_memory"
# Set all filenames
temp_dir = os.path.dirname(os.path.abspath(in_netcdf)) # Emm, csv and img must be saved with .nc
layer1 = relocate(in_netcdf, temp_dir, ".img")
if not os.path.exists(layer1):
fn_csv = relocate(in_netcdf, temp_dir, ".csv")
cnt_dir = os.path.dirname(in_netcdf) + "\\cnt"
# UnComment this to skip existed results
if os.path.exists(relocate(fn_csv, cnt_dir, ".shp")):
print("%s existed. Skip!" % relocate(fn_csv, cnt_dir, ".shp"))
return
ds = netCDF4.Dataset(in_netcdf)
# Level 7 == 3.5km
refl_l = numpy.ravel(ds.variables["WNDSPD_850MB"])
lon_l = numpy.ravel(ds.variables["lon"])
lat_l = numpy.ravel(ds.variables["lat"])
lon_l, lat_l = utils.projFunc(lon_l, lat_l)
print(fn_csv)
if not os.path.exists(fn_csv):
f_csv = open(fn_csv, "w")
f_csv.write("Id,X,Y,Reflect\n")
for i in range(refl_l.shape[0]):
if not refl_l[i] >= 10:
continue
refl = refl_l[i]
lat = lat_l[i]
lon = lon_l[i]
f_csv.write("%d,%f,%f,%f\n" % (i, lon, lat, refl))
f_csv.close()
print("NC to CSV:", fn_csv)
else:
print("Have CSV:", fn_csv)
reflect = arcpy.CreateUniqueName(arcpy.ValidateTableName("reflect.shp"), workspace)
arcpy.MakeXYEventLayer_management(fn_csv, 'X', 'Y', reflect, utils.spatialRef, "Reflect")
arcpy.PointToRaster_conversion(reflect, "Reflect", layer1, cellsize=utils.resolution)
arcpy.DefineProjection_management(layer1, utils.spatialRef)
print("CSV to Rsater:", layer1)
# Apply mask on if provided
#if mask is not None:
# l2 = arcpy.sa.ExtractByMask(in_netcdf, mask)
# l21 = arcpy.sa.Con(l2, l2, 0, "VALUE >= 10")
#else:
# layer1 = in_netcdf
# l21 = arcpy.sa.Con(layer1, layer1, 0, "VALUE >= 10")
l22 = arcpy.sa.Con(arcpy.sa.IsNull(layer1), 0, layer1)
arcpy.sa.ContourList(l22, out_feat, levels)
print("Raster to Contour:", out_feat)
def create_folder_in_scratch(folderName): # create the folders necessary for the job scratch = arcpy.env.scratchWorkspace #scratch = sys.path[0] folderPath = arcpy.CreateUniqueName(folderName, scratch) arcpy.CreateFolder_management(scratch, os.path.basename(folderPath)) return folderPath
def make_output_path(raster, inLayerName, outLayerName, convert, formatList, zipFolderPath, scratchFolderPath, outputDataFolderName='data'):
outFormat = formatList[1].lower()
if convert:
outwkspc = get_temp_location_path(zipFolderPath, outFormat, outputDataFolderName=outputDataFolderName)
else:
outwkspc = get_temp_location_path(scratchFolderPath, "gdb", outputDataFolderName=outputDataFolderName)
if inLayerName.find("\\"):
inLayerName = inLayerName.split("\\")[-1]
# make sure there are no spaces in the out raster name and make sure its less than 13 chars
if outFormat == "grid":
if len(inLayerName) > 12:
inLayerName = inLayerName[:12]
if inLayerName.find(" ") > -1:
inLayerName = inLayerName.replace(" ", "_")
# make the output path
tmpName = os.path.basename(arcpy.CreateUniqueName(outLayerName, outwkspc))
tmpName = arcpy.ValidateTableName(tmpName, outwkspc)
# do some extension housekeeping.
# Raster formats and shp always need to put the extension at the end
if raster or outFormat == "shp":
if outFormat != "gdb" and outFormat != "mdb" and outFormat != "grid":
tmpName += formatList[2].lower()
outputpath = os.path.join(outwkspc, tmpName)
return tmpName, outputpath
def preprocess_inputs(input_features, network_data_source, travel_mode, output_workspace):
"""Preprocess input features so that they can be processed in chunks.
The function performs tasks such as spatially sorting input features and calculate network locations for the
features.
Args:
input_features: The full catalog path to the input feature class.
network_data_source: The catalog path to the network dataset used for analysis
travel_mode: Name of the travel mode used for the analysis.
output_workspace: The catalog path of the output workspace in which to write the output feature class.
Returns:
The full catalog path of the processed feature class.
"""
logger.info("Preprocessing %s", input_features)
# Create output features in a feature class with the same name as input feature class.
desc_input_features = arcpy.Describe(input_features)
input_path = desc_input_features.catalogPath
output_features = arcpy.CreateUniqueName(os.path.basename(input_path), output_workspace)
# Spatially sort input features
logger.debug("Spatially sorting %s", input_features)
result = arcpy.management.Sort(input_features, output_features,
[[desc_input_features.shapeFieldName, "ASCENDING"]], "PEANO")
logger.debug(result.getMessages().split("\n")[-1])
# Calculate network location fields if network data source is local
if not ODCostMatrix.is_nds_service(network_data_source):
logger.debug("Calculating network locations for %s", input_features)
result = arcpy.na.CalculateLocations(output_features, network_data_source, "20 Miles",
ODCostMatrix.get_nds_search_criteria(network_data_source),
travel_mode=travel_mode)
logger.debug(result.getMessages().split("\n")[-1])
return output_features
def create_submersion_matrix(debit, a, b, dem, mask, in_mask, out_sr):
hhh = numpy.exp(a) * float(
debit)**b # hhh = (float(debit)/numpy.exp(b))**(1/a)
pl = hhh < dem # plaine inondable binaire
# Lissage de la plaine inondable binaire
pl = scipy.ndimage.binary_opening(pl,
structure=numpy.ones((3, 3)),
iterations=1).astype(numpy.int)
pl = scipy.ndimage.binary_fill_holes(pl) # .astype(int)
# Conversion en polygon pour eliminer les zones ne touchant pas au lit de la riviere
pl2 = arcpy.NumPyArrayToRaster(
numpy.invert(pl).astype(int), out_sr[2], out_sr[1], out_sr[1])
arcpy.DefineProjection_management(pl2, out_sr[0])
pl2 = pl2 * in_mask
polyg = arcpy.CreateScratchName("", "", "FeatureClass")
polyg = arcpy.CreateUniqueName(polyg)
arcpy.RasterToPolygon_conversion(pl2, polyg, "NO_SIMPLIFY")
arcpy.MakeFeatureLayer_management(
polyg, 'polyg_layer', 'GRIDCODE = 1'
) # Pour les shapefile, le champ est GRIDCODE, sinon grid_code
arcpy.SelectLayerByLocation_management('polyg_layer', "INTERSECT", mask,
'', "NEW_SELECTION")
new_mask = arcpy.CreateScratchName("", "", "RasterDataset")
new_mask = arcpy.CreateUniqueName(new_mask)
arcpy.PolygonToRaster_conversion('polyg_layer', 'GRIDCODE', new_mask,
"CELL_CENTER", "NONE",
out_sr[1]) # inDEM)
# Calcul de la profondeur de submersion
pl = numpy.invert(pl).astype(int) * (dem - hhh)
# Nettoyage des valeurs indesirables
pl[pl < -100] = 0
pl[pl >
0] = -0.001 # les pixels dont la valeur est > 0 sont ceux issus du lissage de la plaine inondable binaire
# Conversion en raster et definition de la projection
rhhh = arcpy.NumPyArrayToRaster(pl, out_sr[2], out_sr[1],
out_sr[1]) * new_mask
arcpy.DefineProjection_management(rhhh, out_sr[0])
return rhhh
def tmp(extension):
"""Generates a unique filename in the scratch folder using arcpy"""
try:
# Only works for ArcGIS 10.1+
scratch = arcpy.env.scratchFolder
except:
# Should be a fix for ArcGIS 10.0
scratch = os.path.join(tempfile.gettempdir(), "scratch")
if not os.path.exists(scratch):
os.mkdir(scratch)
return arcpy.CreateUniqueName("tmp." + extension, scratch)
def _dissolve_multipart(geom_list):
folder = tempfile.mkdtemp()
shape_list = []
for geom in geom_list:
unique_name = arcpy.CreateUniqueName(os.path.join(folder, "xxx.shp"))
arcpy.CopyFeatures_management(geom, unique_name)
shape_list.append(unique_name)
merge_file = arcpy.CreateUniqueName(os.path.join(folder, "xxx.shp"))
arcpy.Merge_management(shape_list, merge_file)
dissolve_file = arcpy.CreateUniqueName(os.path.join(folder, "xxx.shp"))
arcpy.Dissolve_management(merge_file, dissolve_file)
out_poly = None
for row in arcpy.SearchCursor(dissolve_file):
out_poly = copy.copy(row.SHAPE)
break
try:
shutil.rmtree(folder, True)
except Exception, e:
logging.critical(e)
logging.critical("Couldn't delete folder %s" % folder)
def _spatially_sort_input(input_features, tracked_oid_name):
"""Spatially sort the input feature class.
Also adds a field to the input feature class to preserve the original OID values. This field is called
"OriginOID" for origins and "DestinationOID" for destinations.
Args:
input_features (str): Catalog path to the feature class to sort
tracked_oid_name (str): New field name to store original OIDs.
"""
arcpy.AddMessage(
f"Spatially sorting input dataset {input_features}...")
# Add a unique ID field so we don't lose OID info when we sort and can use these later in joins.
# Note that if the original input was a shapefile, these IDs will likely be wrong because copying the original
# input to the output geodatabase will have altered the original ObjectIDs.
# Consequently, don't use shapefiles as inputs.
desc = arcpy.Describe(input_features)
if tracked_oid_name in [f.name for f in desc.fields]:
arcpy.management.DeleteField(input_features, tracked_oid_name)
arcpy.management.AddField(input_features, tracked_oid_name, "LONG")
arcpy.management.CalculateField(input_features, tracked_oid_name,
f"!{desc.oidFieldName}!")
# Make a temporary copy of the inputs so the Sort tool can write its output to the input_features path, which is
# the ultimate desired location
temp_inputs = arcpy.CreateUniqueName(
"TempODInputs", arcpy.env.scratchGDB) # pylint:disable = no-member
arcpy.management.Copy(input_features, temp_inputs)
# Spatially sort input features
try:
arcpy.management.Sort(temp_inputs, input_features,
[[desc.shapeFieldName, "ASCENDING"]],
"PEANO")
except arcpy.ExecuteError: # pylint:disable = no-member
msgs = arcpy.GetMessages(2)
if "000824" in msgs: # ERROR 000824: The tool is not licensed.
arcpy.AddWarning(
"Skipping spatial sorting because the Advanced license is not available."
)
else:
arcpy.AddWarning(
f"Skipping spatial sorting because the tool failed. Messages:\n{msgs}"
)
# Clean up. Delete temporary copy of inputs
arcpy.management.Delete([temp_inputs])
def extract_photos_from_fc(infc, out_folder):
if not os.path.exists(out_folder):
os.mkdir(out_folder)
fldBLOB = 'DATA'
fldAttName = 'ATT_NAME'
fldGlobID = 'REL_GLOBALID'
flds = [fldBLOB, fldAttName, fldGlobID]
#Attachment table
tbl = os.path.join("{}__ATTACH".format(infc))
with arcpy.da.SearchCursor(tbl, flds) as cursor:
for row in cursor:
binaryRep = row[0]
GlobID = row[2]
uniquename = arcpy.CreateUniqueName("{}.jpg".format(GlobID),
out_folder)
open(uniquename, 'wb').write(binaryRep.tobytes())
def crashes_as_json(buffs):
"""prepares crashes for GP Service by converting output to points as FeatureSet()
Required:
buffs -- intersection buffers
"""
crashes = summarize_crashes(buffs)
# convert summarized buffer polygons to points
points = arcpy.CreateUniqueName('CrashPoints', 'in_memory')
# arcpy.FeatureToPoint requires advanced license,use polyfill so it's not required at ArcGIS Server level
featureToPointPolyfill(crashes, points)
# convert to JSON
arcpy.SetParameter(1, arcpy.FeatureSet(points))
def sobreposicao_camadas(camada1, camada2, dissolve=True, keep_atributes=False):
log(id_imovel, 'Classificando tema {0}'.format(camada2))
if (not arcpy.Exists(camada2)):
log(id_imovel, 'Tema {} nao encontrado na base de insumos'.format(camada2))
return None
if keep_atributes:
join_attributes = 'NO_FID'
output = arcpy.CreateUniqueName('INTERSECT', '%scratchGDB%')
else:
join_attributes = 'ONLY_FID'
output = arcpy.Geometry()
intersect = arcpy.Intersect_analysis([camada1, camada2], output, output_type='INPUT', join_attributes=join_attributes)
if not intersect:
return None
if not dissolve:
return intersect
return dissolve_poligonos(intersect)
def AdoptParameter(provided_input, parameter_name, preserve_existing=True):
"""
Copies the provided input into the geodatabase as the parameter_name
parameter. If a feature class already exists with the parameter_name,
a unique copy will be saved (with preserve_existing=True).
Workspace must be defined as project's unique geodatabase before
calling this function.
:param provided_input: a feature class or shapefile
:param parameter_name: the name to save the provided_input as string
:param preserve_existing: True to avoid overwriting
:return: the name of the adopted parameter as a string
"""
# Save a copy of the existing feature class if it already exists
if preserve_existing:
if arcpy.Exists(parameter_name):
new_parameter_name = arcpy.CreateUniqueName(parameter_name)
arcpy.CopyFeatures_management(parameter_name, new_parameter_name)
# Copy providedInput to temporary memory to allow overwriting
arcpy.CopyFeatures_management(provided_input, "in_memory/tmp_provided")
# Delete existing layers in the TOC of the paramaterName
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
m = p.activeMap
for _ in m.listLayers():
arcpy.Delete_management(parameter_name)
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
for _ in arcpy.mapping.ListLayers(mxd, parameter_name):
arcpy.Delete_management(parameter_name)
# Delete feature classes in the geodatabase
for _ in arcpy.ListFeatureClasses(parameter_name):
arcpy.Delete_management(parameter_name)
# Execute renaming
adopted_parameter = arcpy.CopyFeatures_management(
"in_memory/tmp_provided", parameter_name
)
# Clean up
arcpy.Delete_management("in_memory")
return adopted_parameter
def execute(self, parameters, messages):
"""The source code of the tool."""
in_line_features = parameters[0].valueAsText
route_id_field = parameters[1].valueAsText
station_interval = parameters[2].value
cross_section_width = parameters[3].value
out_route_feature_class = parameters[4].valueAsText
out_station_feature_class = parameters[5].valueAsText
out_cross_section_feature_class = parameters[6].valueAsText
arcpy.env.overwriteOutput = True
# Create route from polyline by length
create_route_by_length(in_features=in_line_features,
route_id_field=route_id_field,
route_feature_class=out_route_feature_class)
# Create a unique in_memory name
event_tbl = arcpy.CreateUniqueName('event_table', 'in_memory')
create_point_event_table(out_route_feature_class,
route_id_field_name=route_id_field,
measure_interval=station_interval,
out_table=event_tbl)
# locate points along route
event_properties = '{} {} {}'.format(route_id_field, "POINT",
'Measure')
arcpy.lr.MakeRouteEventLayer(in_routes=out_route_feature_class,
route_id_field=route_id_field,
in_table=event_tbl,
in_event_properties=event_properties,
out_layer='Point Events',
add_angle_field=True,
angle_type="NORMAL",
point_event_type="POINT")
# Save points to feature class
arcpy.management.CopyFeatures('Point Events',
out_station_feature_class)
#Create x section
create_cross_section(out_station_feature_class, route_id_field,
cross_section_width,
out_cross_section_feature_class)
return
def execute(self, parameters, messages):
"""The source code of the tool."""
in_line_features = parameters[0].valueAsText
route_id_field = parameters[1].valueAsText
measure_interval = parameters[2].value
out_point_feature_class = parameters[3].valueAsText
out_route_feature_class = parameters[4].valueAsText
arcpy.env.overwriteOutput = True
# Create route from polyline by length
create_route_by_length(in_features=in_line_features,
route_id_field=route_id_field,
route_feature_class=out_route_feature_class)
# Create a set of UniqueNames for in_memory features
event_tbl = arcpy.CreateUniqueName('event_table', 'in_memory')
#point_fc = arcpy.CreateUniqueName('point_fc', 'in_memory')
# Create point event table
create_point_event_table(out_route_feature_class,
route_id_field_name=route_id_field,
measure_interval=measure_interval,
out_table=event_tbl)
# locate points along route
event_properties = '{} {} {}'.format(route_id_field, "POINT",
'Measure')
arcpy.lr.MakeRouteEventLayer(in_routes=out_route_feature_class,
route_id_field=route_id_field,
in_table=event_tbl,
in_event_properties=event_properties,
out_layer='Point Events',
add_angle_field=True,
angle_type="NORMAL",
point_event_type="POINT")
# Save points to feature class
arcpy.management.CopyFeatures('Point Events', out_point_feature_class)
# Cleanup
if arcpy.Exists(event_tbl):
arcpy.management.Delete(event_tbl)
if arcpy.Exists('Point Events'):
arcpy.management.Delete('Point Events')
return
def create_route_by_length(in_features, route_id_field, route_feature_class):
"""Converts features into measured routes based on the length of the lines.
The input line features that share a common identifier are merged to create
a single route.
Process should only be run on simple lines (no multi-part).
If merging on common id, geometry direction should also align.
"""
# Create a unique in_memory name
the_line = arcpy.CreateUniqueName('theLine', 'in_memory')
# Copy to memory as to not alter original and speed
arcpy.management.CopyFeatures(in_features, the_line)
# Add Fields
arcpy.management.AddField(the_line,
'FromMeasure',
"DOUBLE",
field_is_nullable='NULLABLE',
field_is_required='NON_REQUIRED')
arcpy.management.AddField(the_line,
'ToMeasure',
"DOUBLE",
field_is_nullable='NULLABLE',
field_is_required='NON_REQUIRED')
# Update the in_memory table
update_fields = ['FromMeasure', 'ToMeasure', 'SHAPE@LENGTH']
with arcpy.da.UpdateCursor(the_line, update_fields) as cursor:
for row in cursor:
row[0] = 0
row[1] = row[2]
cursor.updateRow(row)
# Create Route
arcpy.lr.CreateRoutes(the_line,
route_id_field,
route_feature_class,
measure_source='TWO_FIELDS',
from_measure_field='FromMeasure',
to_measure_field='ToMeasure')
# Delete the in_memory line
arcpy.management.Delete(the_line)
# Return the route
return route_feature_class
def InitializeNames(gname,
tname=None,
temptable=False,
scratch=None,
replacechars=None):
# Was this just a table name or a GDB and table name
if temptable == True:
local_gname, local_tname, local_fname = DecodeNames(gname, tname)
if local_gname == "":
local_gname = arcpy.env.scratchGDB if scratch == None else scratch
local_tname = ParseTableName(local_tname, replacechars)
return DecodeNames(
arcpy.CreateUniqueName(ParseTableName(local_tname, replacechars),
local_gname))
else:
local_tname = ParseTableName(tname, replacechars) if tname else None
return DecodeNames(gname, local_tname)
def union(fcCarto,
fcPlanif,
scrWS,
consideraFecha=False,
cfecha="FCH_TRAN",
fcNoPlanif="Cosecha_No_Planificada",
fcRemanente="Remanente",
cPctje="PCT_MES"):
#-------------------------------------------------------------------------------------------------------------------------
oldWS = arcpy.env.workspace
arcpy.env.workspace = scrWS
union = "UNION"
union = arcpy.CreateUniqueName(union)
arcpy.Union_analysis([[fcCarto, 1], [fcPlanif, 2]], union, "ALL", eps)
agregarCampos(union, cfecha)
agregarHAS(union, "HAS")
agregarPCTJE(union, "HAS", cPctje, "AREA_1")
arcpy.env.workspace = oldWS
return (corto(union))
def __init__(self, remote_assets, fixed_assets, network_dataset,
output_gdb):
self.remote = remote_assets
self.fixed = fixed_assets
self.network = network_dataset
self.gdb = arcpy.CreateUniqueName(TEMP_GDB, output_gdb)
# Find the default cost
impedance = filter(lambda f: f.usageType == "Cost" and f.useByDefault,
arcpy.Describe(self.network).attributes)[0].name
cf = arcpy.na.MakeClosestFacilityLayer(self.network,
common.unique_name("tempNA"),
impedance)[0]
desc = arcpy.Describe(cf)
# Get the default locator information to build search_criteria
self.criteria = [[
getattr(desc.locators, "source{}".format(i)),
getattr(desc.locators, "snapType{}".format(i))
] for i in range(desc.locatorCount)]
self.tolerance = desc.searchTolerance
common.delete(cf)
def create_archive(archive_folder, output_file):
"""
archive_folder: Folder to store zip file
output_file: Feature class to be archived
Creates a zip file containing a shapefile representation of the
output_file.
If the output_file is not a shapefile, it creates a temporary shapefile to
add to the archive.
"""
output_desc = arcpy.Describe(output_file)
if not output_desc.dataType == 'ShapeFile':
"""
If output_file isn't a shapefile, create a temporary one to
use for archiving
"""
temp_name = arcpy.CreateUniqueName(os.path.basename(output_file),
arcpy.env.scratchFolder)
temp_file = os.path.join(os.environ['TMP'], temp_name)
arcpy.CopyFeatures_management(output_file, temp_file)
output_file = temp_file
logger.logMsg('Creating temporary shapefile %s for archiving' %
output_file)
logger.logMsg('output_desc.file: %s' % output_desc.file)
archive_file = output_desc.file
archive_file += '_'
archive_file += date.isoformat(datetime.now())
archive_file += '.zip'
archive_filepath = os.path.join(archive_folder, archive_file)
logger.logMsg('Archiving %s to %s' % (output_file, archive_filepath))
output_desc = arcpy.Describe(output_file)
try:
with zipfile.ZipFile(archive_filepath,
mode='w',
compression=zipfile.ZIP_DEFLATED) as zf:
shape_zipper(output_file, zf)
zip_info(zf)
except arcpy.ExecuteError as e:
raise e
logger.logError()
def accuracy_analysis(test_samples,classified_image):
confuse = {}
for i in range(1,7):
for j in range(1,7):
confuse[i,j] = 0
#从分类结果图像中提取验证样本点对应的分类值，产生新的验证样本点文件
outPointFeatures = arcpy.CreateUniqueName("c:\\data\\tmp\\xx.shp")
ExtractValuesToPoints(test_samples,classified_image,outPointFeatures)
#产生混淆矩阵
cur = arcpy.SearchCursor(outPointFeatures)
n = 0
for row in cur:
n = n + 1
i = row.GrndTruth
j = row.RASTERVALU
confuse[i,j] = confuse[i,j] + 1
del outPointFeatures
#根据混淆矩阵计算分类总精度和Kappa系数
right_n = 0
row_column = 0
for k in range(1,7):
right_n = right_n + confuse[k,k]
row = 0
for r in range(1,7):
row = confuse[k,r] +row
column = 0
for c in range(1,7):
column = confuse[c,k] +column
row_column = row*column + row_column
overall_precise = float(right_n)/float(n)
Kappa = float(n*right_n - row_column)/float(n*n - row_column)
print "n:",n
print "overall_precise:",overall_precise
print "Kappa:",Kappa
height_files = {
'multipoint': None,
'tin': None,
'raster': os.path.join(support_folder, 'dhm.tif'),
'name': 'height'
}
intensity_files = {
'multipoint': None,
'tin': None,
'raster': os.path.join(support_folder, 'intensity.tif'),
'rawraster': os.path.join(support_folder, 'intensity.tif'),
'name': 'intensity'
}
arcpy.AddMessage("Generating DSM")
surfaceLyr = arcpy.CreateUniqueName('First Return Layer')
arcpy.MakeLasDatasetLayer_management(
in_las_dataset=inlasd,
out_layer=surfaceLyr,
class_code=None,
return_values=['Single Return', 'First of Many'])
arcpy.LasDatasetToRaster_conversion(
in_las_dataset=surfaceLyr,
out_raster=surface_files['rawraster'],
value_field='ELEVATION',
interpolation_type=
"TRIANGULATION NATURAL_NEIGHBOR NO_THINNING CLOSEST_TO_MEAN 0",
# 'TRIANGULATION Linear {point_thinning_type} {point_selection_method} {resolution}',
data_type='FLOAT',
sampling_type='CELLSIZE',
sampling_value=cell_edge_length,
def clip_data(input_items, out_workspace, out_coordinate_system, gcs_sr, gcs_clip_poly, out_format):
"""Clips input results."""
clipped = 0
errors = 0
skipped = 0
fds = None
global processed_count
global layer_name
global existing_fields
global new_fields
global field_values
for ds, out_name in input_items.items():
try:
if not isinstance(out_name, list):
out_name = ''
# -----------------------------------------------
# If the item is a service layer, process and continue.
# -----------------------------------------------
if ds.startswith('http'):
try:
if out_coordinate_system == 0:
service_layer = task_utils.ServiceLayer(ds)
wkid = service_layer.wkid
out_sr = arcpy.SpatialReference(wkid)
arcpy.env.outputCoordinateSystem = out_sr
else:
out_sr = task_utils.get_spatial_reference(out_coordinate_system)
arcpy.env.outputCoordinateSystem = out_sr
if not out_sr.name == gcs_sr.name:
try:
geo_transformation = arcpy.ListTransformations(gcs_sr, out_sr)[0]
clip_poly = gcs_clip_poly.projectAs(out_sr, geo_transformation)
except (AttributeError, IndexError):
try:
clip_poly = gcs_clip_poly.projectAs(out_sr)
except AttributeError:
clip_poly = gcs_clip_poly
except ValueError:
clip_poly = gcs_clip_poly
else:
clip_poly = gcs_clip_poly
arcpy.env.overwriteOutput = True
service_layer = task_utils.ServiceLayer(ds, clip_poly.extent.JSON, 'esriGeometryEnvelope')
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&f=json".format(where, '*', eval(clip_poly.JSON))
feature_set = arcpy.FeatureSet()
if not out_name:
out_name = service_layer.service_layer_name
try:
feature_set.load(url)
except Exception:
continue
if not out_features:
out_features = arcpy.Clip_analysis(feature_set, clip_poly, out_name)
else:
clip_features = arcpy.Clip_analysis(feature_set, clip_poly, 'in_memory/features')
arcpy.Append_management(clip_features, out_features, 'NO_TEST')
try:
arcpy.Delete_management(clip_features)
except arcpy.ExecuteError:
pass
status_writer.send_percent(float(g) / group_cnt, '', 'clip_data')
processed_count += 1.
clipped += 1
status_writer.send_percent(processed_count / result_count, _('Clipped: {0}').format(ds), 'clip_data')
continue
except Exception as ex:
status_writer.send_state(status.STAT_WARNING, str(ex))
errors_reasons[ds] = ex.message
errors += 1
continue
# -----------------------------------------------
# Check if the path is a MXD data frame type.
# ------------------------------------------------
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):
for row in out_name:
try:
arcpy.env.overwriteOutput = True
name = os.path.join(out_workspace, arcpy.ValidateTableName(ds, out_workspace))
if out_format == 'SHP':
name += '.shp'
# Clip the geometry.
geo_json = row['[geo]']
geom = arcpy.AsShape(geo_json)
row.pop('[geo]')
if not arcpy.Exists(name):
if arcpy.env.outputCoordinateSystem:
arcpy.CreateFeatureclass_management(out_workspace, os.path.basename(name), geom.type.upper())
else:
arcpy.env.outputCoordinateSystem = 4326
arcpy.CreateFeatureclass_management(out_workspace, os.path.basename(name), geom.type.upper())
layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer')
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_workspace)
new_fields.append(valid_field)
field_values.append(value)
try:
arcpy.AddField_management(layer_name, valid_field, 'TEXT')
except arcpy.ExecuteError:
arcpy.DeleteField_management(layer_name, valid_field)
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_workspace)
if arcpy.env.outputCoordinateSystem:
arcpy.CreateFeatureclass_management(out_workspace, os.path.basename(name), geom.type.upper())
else:
arcpy.env.outputCoordinateSystem = 4326
arcpy.CreateFeatureclass_management(out_workspace, os.path.basename(name), geom.type.upper())
layer_name = arcpy.MakeFeatureLayer_management(name, 'flayer')
existing_fields = [f.name for f in arcpy.ListFields(layer_name)]
new_fields = []
field_values = []
for field, value in row.items():
valid_field = arcpy.ValidateFieldName(field, out_workspace)
new_fields.append(valid_field)
field_values.append(value)
if not valid_field in existing_fields:
try:
arcpy.AddField_management(layer_name, valid_field, 'TEXT')
except arcpy.ExecuteError:
arcpy.DeleteField_management(layer_name, valid_field)
arcpy.AddField_management(layer_name, valid_field, 'TEXT')
clipped_geometry = arcpy.Clip_analysis(geom, gcs_clip_poly, arcpy.Geometry())
if clipped_geometry:
with arcpy.da.InsertCursor(layer_name, ["SHAPE@"] + new_fields) as icur:
icur.insertRow([clipped_geometry[0]] + field_values)
status_writer.send_percent(processed_count / result_count, _('Clipped: {0}').format(row['name']), 'clip_data')
processed_count += 1
clipped += 1
except KeyError:
processed_count += 1
skipped += 1
status_writer.send_state(_(status.STAT_WARNING, 'Invalid input type: {0}').format(ds))
skipped_reasons[ds] = 'Invalid input type'
except Exception as ex:
processed_count += 1
errors += 1
errors_reasons[ds] = ex.message
continue
continue
dsc = arcpy.Describe(ds)
try:
if dsc.spatialReference.name == 'Unknown':
status_writer.send_state(status.STAT_WARNING, _('{0} has an Unknown projection. Output may be invalid or empty.').format(dsc.name))
except AttributeError:
pass
# --------------------------------------------------------------------
# If no output coord. system, get output spatial reference from input.
# --------------------------------------------------------------------
if out_coordinate_system == 0:
try:
out_sr = dsc.spatialReference
arcpy.env.outputCoordinateSystem = out_sr
except AttributeError:
out_sr = task_utils.get_spatial_reference(4326)
arcpy.env.outputCoordinateSystem = out_sr
else:
out_sr = task_utils.get_spatial_reference(out_coordinate_system)
arcpy.env.outputCoordinateSystem = out_sr
# -------------------------------------------------
# If the item is not a file, project the clip area.
# -------------------------------------------------
if dsc.dataType not in ('File', 'TextFile'):
if not out_sr.name == gcs_sr.name:
try:
geo_transformation = arcpy.ListTransformations(gcs_sr, out_sr)[0]
clip_poly = gcs_clip_poly.projectAs(out_sr, geo_transformation)
except (AttributeError, IndexError):
try:
clip_poly = gcs_clip_poly.projectAs(out_sr)
except AttributeError:
clip_poly = gcs_clip_poly
except ValueError:
clip_poly = gcs_clip_poly
else:
clip_poly = gcs_clip_poly
extent = clip_poly.extent
# -----------------------------
# Check the data type and clip.
# -----------------------------
# Feature Class or ShapeFile
if dsc.dataType in ('FeatureClass', 'ShapeFile', 'Shapefile'):
if out_name == '':
name = arcpy.ValidateTableName(dsc.name, out_workspace)
name = task_utils.create_unique_name(name, out_workspace)
else:
name = arcpy.ValidateTableName(out_name, out_workspace)
name = task_utils.create_unique_name(name, out_workspace)
# Does the input exist in a feature dataset? If so, create the feature dataset if it doesn't exist.
ws = os.path.dirname(ds)
if [any(ext) for ext in ('.gdb', '.mdb', '.sde') if ext in ws]:
if os.path.splitext(ws)[1] in ('.gdb', '.mdb', '.sde'):
arcpy.Clip_analysis(ds, clip_poly, name)
else:
fds_name = os.path.basename(ws)
if not arcpy.Exists(os.path.join(out_workspace, fds_name)):
arcpy.CreateFeatureDataset_management(out_workspace, fds_name, dsc.spatialReference)
arcpy.Clip_analysis(ds, clip_poly, os.path.join(out_workspace, fds_name, os.path.basename(ds)))
else:
arcpy.Clip_analysis(ds, clip_poly, name)
# Feature dataset
elif dsc.dataType == 'FeatureDataset':
if not out_format == 'SHP':
fds_name = os.path.basename(task_utils.create_unique_name(dsc.name, out_workspace))
fds = arcpy.CreateFeatureDataset_management(out_workspace, fds_name)
arcpy.env.workspace = ds
for fc in arcpy.ListFeatureClasses():
try:
if not out_format == 'SHP':
arcpy.Clip_analysis(fc, clip_poly, task_utils.create_unique_name(fc, fds.getOutput(0)))
else:
arcpy.Clip_analysis(fc, clip_poly, task_utils.create_unique_name(fc, out_workspace))
except arcpy.ExecuteError:
pass
arcpy.env.workspace = out_workspace
# Raster dataset
elif dsc.dataType == 'RasterDataset':
if out_name == '':
name = task_utils.create_unique_name(dsc.name, out_workspace)
else:
name = task_utils.create_unique_name(out_name, out_workspace)
ext = '{0} {1} {2} {3}'.format(extent.XMin, extent.YMin, extent.XMax, extent.YMax)
arcpy.Clip_management(ds, ext, name, in_template_dataset=clip_poly, clipping_geometry="ClippingGeometry")
# Layer file
elif dsc.dataType == 'Layer':
task_utils.clip_layer_file(dsc.catalogPath, clip_poly, arcpy.env.workspace)
# Cad drawing dataset
elif dsc.dataType == 'CadDrawingDataset':
arcpy.env.workspace = dsc.catalogPath
cad_wks_name = os.path.splitext(dsc.name)[0]
for cad_fc in arcpy.ListFeatureClasses():
name = task_utils.create_unique_name('{0}_{1}'.format(cad_wks_name, cad_fc), out_workspace)
arcpy.Clip_analysis(cad_fc, clip_poly, name)
arcpy.env.workspace = out_workspace
# File
elif dsc.dataType in ('File', 'TextFile'):
if dsc.catalogPath.endswith('.kml') or dsc.catalogPath.endswith('.kmz'):
name = os.path.splitext(dsc.name)[0]
kml_layer = arcpy.KMLToLayer_conversion(dsc.catalogPath, arcpy.env.scratchFolder, name)
group_layer = arcpy.mapping.Layer(os.path.join(arcpy.env.scratchFolder, '{0}.lyr'.format(name)))
for layer in arcpy.mapping.ListLayers(group_layer):
if layer.isFeatureLayer:
arcpy.Clip_analysis(layer,
gcs_clip_poly,
task_utils.create_unique_name(layer, out_workspace))
# Clean up temp KML results.
arcpy.Delete_management(os.path.join(arcpy.env.scratchFolder, '{0}.lyr'.format(name)))
arcpy.Delete_management(kml_layer[1])
del group_layer
else:
if out_name == '':
out_name = dsc.name
if out_workspace.endswith('.gdb'):
f = arcpy.Copy_management(ds, os.path.join(os.path.dirname(out_workspace), out_name))
else:
f = arcpy.Copy_management(ds, os.path.join(out_workspace, out_name))
processed_count += 1.
status_writer.send_percent(processed_count / result_count, _('Copied file: {0}').format(dsc.name), 'clip_data')
status_writer.send_state(_('Copied file: {0}').format(dsc.name))
clipped += 1
if out_format in ('LPK', 'MPK'):
files_to_package.append(f.getOutput(0))
continue
# Map document
elif dsc.dataType == 'MapDocument':
task_utils.clip_mxd_layers(dsc.catalogPath, clip_poly, arcpy.env.workspace, map_frame_name)
else:
processed_count += 1.
status_writer.send_percent(processed_count / result_count, _('Invalid input type: {0}').format(ds), 'clip_data')
status_writer.send_state(status.STAT_WARNING, _('Invalid input type: {0}').format(ds))
skipped += 1
skipped_reasons[ds] = _('Invalid input type: {0}').format(dsc.dataType)
continue
processed_count += 1.
status_writer.send_percent(processed_count / result_count, _('Clipped: {0}').format(dsc.name), 'clip_data')
status_writer.send_status(_('Clipped: {0}').format(dsc.name))
clipped += 1
# Continue. Process as many as possible.
except Exception as ex:
processed_count += 1.
status_writer.send_percent(processed_count / result_count, _('Skipped: {0}').format(os.path.basename(ds)), 'clip_data')
status_writer.send_status(_('FAIL: {0}').format(repr(ex)))
errors_reasons[ds] = ex.message
errors += 1
pass
return clipped, errors, skipped
def execute(request):
"""Creates a GeoPDF.
:param request: json as a dict.
"""
added_to_map = 0
errors = 0
skipped = 0
parameters = request['params']
num_results, response_index = task_utils.get_result_count(parameters)
docs = parameters[response_index]['response']['docs']
input_items = task_utils.get_input_items(docs)
input_rows = collections.defaultdict(list)
for doc in docs:
if 'path' not in doc:
input_rows[doc['name']].append(doc)
if num_results > task_utils.CHUNK_SIZE:
status_writer.send_state(status.STAT_FAILED,
'Reduce results to 25 or less.')
return
map_template = task_utils.get_parameter_value(parameters, 'map_template',
'value')
base_map = task_utils.get_parameter_value(parameters, 'base_map', 'value')
map_title = task_utils.get_parameter_value(parameters, 'map_title',
'value')
attribute_setting = task_utils.get_parameter_value(parameters,
'attribute_settings',
'value')
author = task_utils.get_parameter_value(parameters, 'map_author', 'value')
output_file_name = task_utils.get_parameter_value(parameters,
'output_file_name',
'value')
if not output_file_name:
output_file_name = 'output_pdf'
try:
map_view = task_utils.get_parameter_value(parameters, 'map_view',
'extent')
except KeyError:
map_view = None
pass
temp_folder = os.path.join(request['folder'], 'temp')
if not os.path.exists(temp_folder):
os.makedirs(temp_folder)
if base_map == 'NONE':
base_layer = None
else:
base_layer = arcpy.mapping.Layer(
os.path.join(os.path.dirname(os.path.dirname(__file__)),
'supportfiles', 'basemaps',
'{0}.lyr'.format(base_map)))
mxd_path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
'supportfiles', 'frame', map_template)
mxd = arcpy.mapping.MapDocument(mxd_path)
data_frame = arcpy.mapping.ListDataFrames(mxd)[0]
layers = []
all_layers = []
if input_rows:
for name, rows in input_rows.iteritems():
for row in rows:
try:
name = arcpy.CreateUniqueName(name, 'in_memory')
# Create the geometry.
geo_json = row['[geo]']
geom = arcpy.AsShape(geo_json)
arcpy.CopyFeatures_management(geom, name)
feature_layer = arcpy.MakeFeatureLayer_management(
name, os.path.basename(name))
layer_file = arcpy.SaveToLayerFile_management(
feature_layer,
os.path.join(temp_folder,
'{0}.lyr'.format(os.path.basename(name))))
layers.append(arcpy.mapping.Layer(layer_file.getOutput(0)))
all_layers.append(
arcpy.mapping.Layer(layer_file.getOutput(0)))
added_to_map += 1
except KeyError:
skipped += 1
skipped_reasons[name] = 'No geographic information'
continue
for i, item in enumerate(input_items, 1):
try:
# Is the item a mxd data frame.
map_frame_name = task_utils.get_data_frame_name(item)
if map_frame_name:
item = item.split('|')[0].strip()
dsc = arcpy.Describe(item)
if dsc.dataType == 'Layer':
layers.append(arcpy.mapping.Layer(dsc.catalogPath))
elif dsc.dataType == 'FeatureClass' or dsc.dataType == 'ShapeFile':
if os.path.basename(item) in [l.name for l in all_layers]:
layer_name = '{0}_{1}'.format(os.path.basename(item), i)
else:
layer_name = os.path.basename(item)
feature_layer = arcpy.MakeFeatureLayer_management(
item, layer_name)
layer_file = arcpy.SaveToLayerFile_management(
feature_layer,
os.path.join(temp_folder, '{0}.lyr'.format(layer_name)))
layers.append(arcpy.mapping.Layer(layer_file.getOutput(0)))
all_layers.append(arcpy.mapping.Layer(layer_file.getOutput(0)))
elif dsc.dataType == 'FeatureDataset':
arcpy.env.workspace = item
for fc in arcpy.ListFeatureClasses():
layer_file = arcpy.SaveToLayerFile_management(
arcpy.MakeFeatureLayer_management(
fc, '{0}_{1}'.format(fc, i)),
os.path.join(temp_folder, '{0}_{1}.lyr'.format(fc, i)))
layer = arcpy.mapping.Layer(layer_file.getOutput(0))
layer.name = fc
layers.append(layer)
all_layers.append(layer)
elif dsc.dataType == 'RasterDataset':
if os.path.basename(item) in [l.name for l in all_layers]:
layer_name = '{0}_{1}'.format(os.path.basename(item), i)
else:
layer_name = os.path.basename(item)
raster_layer = arcpy.MakeRasterLayer_management(
item, layer_name)
layer_file = arcpy.SaveToLayerFile_management(
raster_layer,
os.path.join(temp_folder, '{0}.lyr'.format(layer_name)))
layers.append(arcpy.mapping.Layer(layer_file.getOutput(0)))
all_layers.append(arcpy.mapping.Layer(layer_file.getOutput(0)))
elif dsc.catalogPath.endswith('.kml') or dsc.catalogPath.endswith(
'.kmz'):
if not os.path.splitext(dsc.name)[0] in layers:
name = os.path.splitext(dsc.name)[0]
else:
name = '{0}_{1}'.format(os.path.splitext(dsc.name)[0], i)
arcpy.KMLToLayer_conversion(dsc.catalogPath, temp_folder, name)
layers.append(
arcpy.mapping.Layer(
os.path.join(temp_folder, '{0}.lyr'.format(name))))
all_layers.append(
arcpy.mapping.Layer(
os.path.join(temp_folder, '{0}.lyr'.format(name))))
elif dsc.dataType == 'MapDocument':
input_mxd = arcpy.mapping.MapDocument(item)
if map_frame_name:
df = arcpy.mapping.ListDataFrames(input_mxd,
map_frame_name)[0]
layers = arcpy.mapping.ListLayers(input_mxd, data_frame=df)
else:
layers = arcpy.mapping.ListLayers(input_mxd)
if layers:
for layer in layers:
status_writer.send_status(
_('Adding layer {0}...').format(layer.name))
arcpy.mapping.AddLayer(data_frame, layer)
added_to_map += 1
layers = []
else:
status_writer.send_status(
_('Invalid input type: {0}').format(item))
skipped_reasons[item] = 'Invalid input type'
skipped += 1
except Exception as ex:
status_writer.send_status(_('FAIL: {0}').format(repr(ex)))
errors += 1
errors_reasons[item] = repr(ex)
pass
if map_view:
extent = map_view.split(' ')
new_extent = data_frame.extent
new_extent.XMin, new_extent.YMin = float(extent[0]), float(extent[1])
new_extent.XMax, new_extent.YMax = float(extent[2]), float(extent[3])
data_frame.extent = new_extent
else:
data_frame.zoomToSelectedFeatures()
# Update text elements in map template.
date_element = arcpy.mapping.ListLayoutElements(mxd, 'TEXT_ELEMENT',
'date')
if date_element:
date_element[0].text = 'Date: {0}'.format(task_utils.get_local_date())
title_element = arcpy.mapping.ListLayoutElements(mxd, 'TEXT_ELEMENT',
'title')
if title_element:
title_element[0].text = map_title
author_element = arcpy.mapping.ListLayoutElements(mxd, 'TEXT_ELEMENT',
'author')
if author_element:
author_element[0].text = '{0} {1}'.format(author_element[0].text,
author)
if map_template in ('ANSI_D_LND.mxd', 'ANSI_E_LND.mxd'):
coord_elements = arcpy.mapping.ListLayoutElements(
mxd, 'TEXT_ELEMENT', 'x*')
coord_elements += arcpy.mapping.ListLayoutElements(
mxd, 'TEXT_ELEMENT', 'y*')
if coord_elements:
for e in coord_elements:
new_text = e.text
if e.name == 'xmin':
dms = task_utils.dd_to_dms(data_frame.extent.XMin)
if data_frame.extent.XMin > 0:
new_text = new_text.replace('W', 'E')
elif e.name == 'xmax':
dms = task_utils.dd_to_dms(data_frame.extent.XMax)
if data_frame.extent.XMax > 0:
new_text = new_text.replace('W', 'E')
elif e.name == 'ymin':
dms = task_utils.dd_to_dms(data_frame.extent.YMin)
if data_frame.extent.YMin < 0:
new_text = new_text.replace('N', 'S')
elif e.name == 'ymax':
if data_frame.extent.YMax < 0:
new_text = new_text.replace('N', 'S')
dms = task_utils.dd_to_dms(data_frame.extent.YMax)
new_text = new_text.replace('d', str(dms[0]))
new_text = new_text.replace('m', str(dms[1]))
new_text = new_text.replace('s', str(dms[2]))
e.text = new_text
# Do this now so it does not affect zoom level or extent.
if base_layer:
status_writer.send_status(_('Adding basemap {0}...').format(base_map))
arcpy.mapping.AddLayer(data_frame, base_layer, 'BOTTOM')
if added_to_map > 0:
status_writer.send_status(_('Exporting to PDF...'))
arcpy.mapping.ExportToPDF(mxd,
os.path.join(
request['folder'],
'{0}.pdf'.format(output_file_name)),
layers_attributes=attribute_setting)
# Create a thumbnail size PNG of the mxd.
task_utils.make_thumbnail(
mxd, os.path.join(request['folder'], '_thumb.png'), False)
else:
status_writer.send_state(status.STAT_FAILED,
_('No results can be exported to PDF'))
task_utils.report(os.path.join(request['folder'], '__report.json'),
added_to_map,
skipped,
skipped_details=skipped_reasons)
return
# Update state if necessary.
if skipped > 0 or errors > 0:
status_writer.send_state(
status.STAT_WARNING,
_('{0} results could not be processed').format(skipped + errors))
task_utils.report(os.path.join(request['folder'],
'__report.json'), added_to_map, skipped,
errors, errors_reasons, skipped_reasons)
def tmp(extension):
"""Generates a unique filename in the scratch folder using arcpy"""
return arcpy.CreateUniqueName("tmp." + extension, arcpy.env.scratchFolder)
