def process(): # TODO: Add User Error Reporting alerting user of issue with accessing their bucket. # Begin Script class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError try: bucket_url = 'https://s3.{0}.amazonaws.com/{1}/'.format(region, bucket_name) f_list = [] fp_list = [] ''' conn = client('s3') # again assumes boto.cfg setup, assume AWS S3 for key in conn.list_objects(Bucket=bucket_name)['Contents']: if not key['Key'].endswith('/') and list_folders is False: f_list.append(key['Key']) fp_list.append(bucket_url + key['Key']) if list_folders is True: f_list.append(key['Key']) fp_list.append(bucket_url + key['Key']) ''' s3r = resource('s3') bucket_list = [item.key for item in list(s3r.Bucket(bucket_name).objects.all())] for key in bucket_list: if not key.endswith('/') and list_folders is False: f_list.append(key) fp_list.append(bucket_url + key) if list_folders is True: f_list.append(key) fp_list.append(bucket_url + key) # Create a Pandas dataframe from the data. df = pd.DataFrame({'bucket_url': bucket_url, 'key': f_list, 'full_path': fp_list}) with pd.ExcelWriter(out_spreadsheet) as writer: df.to_excel(writer) except NoCredentialsError: err_str = 'Detected Boto3 Credentials are not set. see the following instructions ' \ 'https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#configuration' AddError(err_str) raiseValueError(err_str) except s3_client.exceptions.NoSuchBucket: AddError('Aws bucket %s does not exist' % bucket_name) raise ValueError('Aws bucket %s does not exist' % bucket_name) # Check back in Image Analyst license CheckInExtension("ImageAnalyst") except LicenseError: AddError("ImageAnalyst license is unavailable") print("ImageAnalyst license is unavailable") except ExecuteError: AddError(GetMessages(2)) print(GetMessages(2))
def checkout_arcgis_extension(extension): """""" if CheckExtension(extension) == 'Available': CheckOutExtension(extension) else: print "the '{}' extension is unavailable so the script can't run " \ "successfully, if you have ArcGIS Desktop open close it, as " \ "it may be utilizing the license, otherwise check the " \ "license server log to determine who has it checked out" exit()
def calculate_network_locations(points, network): """ Computes the locations of |points| in |network|. |points|: a feature class (points or polygons). |network|: a network dataset. """ CheckOutExtension("Network") CalculateLocations_na(in_point_features=points, in_network_dataset=network, search_tolerance="5000 Meters", search_criteria=("%s SHAPE; %s SHAPE;" % network_features(network)), exclude_restricted_elements="INCLUDE") CheckInExtension("Network")
def roadsNonMonoCheck(): try: # Check out license print('The result of CheckExtension("Highways") is ' + str(CheckExtension("Highways")) + '.') if CheckExtension("Highways") == 'Available': CheckOutExtension("Highways") # Do the license check before the deletion, so that you don't # remove data and then not put it back in the case that the # license is not available. from arcpy import DetectNonMonotonicRoutes_locref if Exists(nonMonotonicOutputGDB): try: Delete_management(nonMonotonicOutputGDB) except: pass else: pass nonMonotonicOutputGDBName = returnGDBOrSDEName(nonMonotonicOutputGDB) CreateFileGDB_management(mainFolder, nonMonotonicOutputGDBName) time.sleep(1) DetectNonMonotonicRoutes_locref(networkToReview, nonMonotonicOutputFC, "Any", "F_Date", "T_Date", "SourceRouteId") print("The Roads & Highways Non-Monotonic routes check for " + str(networkToReview) + " has completed.\n") else: print('The Roads & Highways extension is not currently available.') print('Skipping R&H Non-Monotonicity check.') except Exception as Exception1: # If an error occurred, print line number and error message import traceback, sys tb = sys.exc_info()[2] print "Line %i" % tb.tb_lineno print Exception1.message try: del Exception1 except: pass finally: try: # Check the license back in CheckInExtension("Highways") except: pass
def arcpy_schema_compare(self, base, output_folder_location, test): self.queue.put("Importing ArcPy\n\n") from arcpy import CheckOutExtension from arcpy import CheckInExtension from arcpy import env CheckOutExtension('Datareviewer') self.queue.put("Checking Out Datareviewer Extension\n\n") from arcpy import GeodatabaseSchemaCompare_Reviewer env.overwriteOutput = True self.queue.put('Arcpy and Datareviewer checked out\n\n') result = GeodatabaseSchemaCompare_Reviewer( base, test, output_folder_location ) # THIS IS CAUSING PYTHON TO CRASH ON RE_RUN self.queue.put(result.getMessages()) CheckInExtension('Datareviewer') del result self.queue.put("\n\nChecking In Datareviewer Extension\n\n")
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError subset_image_for_texture(in_image, in_polygon, area, out_image) CheckInExtension("ImageAnalyst") except LicenseError: print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages, AddError class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError try: from PIL import Image except ModuleNotFoundError: from arcpy import AddError AddError( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) print( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) exit() i_list, extent = get_images_and_stats( in_mosaic ) # Obtain image statistics and info from mosaic for processing for i in i_list: # Check that output folder is not the path of i if out_folder == path.dirname(i[0]): AddError( "outFolder cannot be the same folder/directory as images referenced in the mosaic dataset" ) exit() if not path.exists(out_folder): makedirs(out_folder) texture_images(i_list, extent, in_texture, in_polygon, out_folder, method, blur_distance) # Generate Texture-Masked tiles CheckInExtension("ImageAnalyst") except LicenseError: AddError("Image Analyst license is unavailable") print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def main(): from arcpy import ExecuteError, GetMessages, CheckOutExtension, CheckExtension, CheckInExtension class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError seamless_texture(inImg, outImg) CheckInExtension("ImageAnalyst") except LicenseError: print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError create_mask(in_raster, in_polygon, out_raster) CheckInExtension("ImageAnalyst") except LicenseError: print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def las_tiles_to_numpy_pandas(in_lidar_folder, sr, lidar_format, returns, class_codes, format_for_library): class LicenseError(Exception): pass try: if CheckExtension("3D") == "Available": CheckOutExtension("3D") else: # raise a custom exception raise LicenseError if not lidar_format.startswith( "."): # Ensure lidar format contains a format decimal lidar_format = ".{}".format(lidar_format) supported_lidar_formats = [".las", ".zlas"] assert lidar_format in supported_lidar_formats, \ "LiDAR format {0} unsupported. Ensure LiDAR format is in {1}".format(lidar_format, supported_lidar_formats) lidar_tiles = [ f for f in listdir(in_lidar_folder) if f.endswith("{}".format(lidar_format)) ] if len(lidar_tiles) < 1: AddError("No LiDAR tiles detected in input directory") count = 0 for tile in lidar_tiles: AddMessage("processing lidar tile {0} of {1} : {2}".format( count + 1, len(lidar_tiles), tile)) lidar_tile = join(in_lidar_folder, tile) las_tile_to_numpy_pandas(lidar_tile, sr, returns, class_codes, format_for_library) count += 1 AddMessage("processing {} lidar tiles complete".format(count)) # Check back in 3D Analyst license CheckInExtension("3D") except LicenseError: AddError("3D Analyst license is unavailable") except ExecuteError: AddError("3D Analyst license is unavailable") print(GetMessages(2))
def initGIS(self): """ Factory method for setting up required ArcPy processing """ # GIS globals env.overwriteOutput = True env.extent = "MINOF" CheckOutExtension("Spatial") self.output_location = os.path.join(os.getcwd(), 'tkinter_output') print self.output_location if not os.path.isdir(self.output_location): os.mkdir(self.output_location) env.workspace = self.output_location self.tracts_file = os.path.join(self.output_location, "cancer_tracts.shp") self.mxd = mapping.MapDocument( os.path.join(self.output_location, "cancer_data.mxd"))
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages, AddMessage from arcpy.management import BuildPyramids class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError try: from PIL import Image except ModuleNotFoundError: from arcpy import AddError AddError( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) print( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) exit() mask_image(in_image, in_mask, in_texture, out_image, method, blur_distance) AddMessage("Building Pyramids") BuildPyramids(out_image, -1, "NONE", "NEAREST", "DEFAULT", 75, "OVERWRITE") CheckInExtension("ImageAnalyst") except LicenseError: print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages, AddError class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError batch_create_tiled_ortho_mosaics(in_folder, image_format, num_bands, pixel_depth, product_definition, product_band_definitions, pixel_size, out_folder) CheckInExtension("ImageAnalyst") except LicenseError: AddError("Image Analyst license is unavailable") print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))
def process(): class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError # System Parameters tile_name = "FileName" # Begin Script temp_fc = join("in_memory", "temp_fc") CopyFeatures(in_fc, temp_fc) for f in file_names: AddField(temp_fc, f, "TEXT") df = pd.read_excel(in_xlsx, index_col=0) def attribute_tile(in_feature_class, in_tile_name, in_df, in_name, xlsx_row_name=xlsx_row_name): with da.UpdateCursor(in_feature_class, [in_tile_name, in_name]) as cursor: for fc_r in cursor: for df_i, df_r in in_df.iterrows(): url = df_r[xlsx_row_name] n = Path(url).stem t_name = fc_r[0] t_n = Path(t_name).stem if n.startswith(in_name) and t_n in n: fc_r[1] = url cursor.updateRow(fc_r) # Attribute the LiDAR Derivatives for n in file_names: attribute_tile(temp_fc, tile_name, df, n) def attribute_tile_lidar(in_feature_class, in_tile_name, in_df, in_name, xlsx_row_name=xlsx_row_name): with da.UpdateCursor(in_feature_class, [in_tile_name, in_name]) as cursor: for fc_r in cursor: for df_i, df_r in in_df.iterrows(): url = df_r[xlsx_row_name] n = split(url)[1] t_name = fc_r[0] if n == t_name: fc_r[1] = url cursor.updateRow(fc_r) # Attribute the LiDAR tile now AddField(temp_fc, in_lidar_format, "TEXT") attribute_tile_lidar(temp_fc, tile_name, df, in_lidar_format, xlsx_row_name=xlsx_row_name) ''' # Print Fields for debugging/assessing results of above operations file_names.append(in_lidar_format) print(file_names) with da.SearchCursor(temp_fc, file_names) as cursor: for fc_r in cursor: print(fc_r) ''' # Delete Pandas Dataframe from Memory del df # Copy in_memory temporary feature class to output location CopyFeatures(temp_fc, out_fc) # Delete Temporary Feature Class Delete(temp_fc) # Check back in Image Analyst license CheckInExtension("ImageAnalyst") except LicenseError: AddError("ImageAnalyst license is unavailable") print("ImageAnalyst license is unavailable") except ExecuteError: AddError(GetMessages(2)) print(GetMessages(2))
def process(): class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError # Constants - DO NOT MODIFY supported_folder_extensions = [ 'gdb' ] # Currently not using this.... for future needs... def ensure_dir(file_path): directory = os.path.dirname(file_path) if not os.path.exists(directory): os.makedirs(directory) def zipper(in_list, out_file_path): out_file = '{0}.zip'.format(out_file_path) ensure_dir(out_file) with zipfile.ZipFile(out_file, 'w') as zipMe: for f in in_list: zipMe.write(f, compress_type=zipfile.ZIP_DEFLATED) def zipper_gdb(in_gdb, out_file_name): assert in_gdb.endswith( '.gdb' ), "Error: file extension {0} not detected in in_folder".format( ".gdb") root_dir = os.path.dirname(in_gdb) gdb_name = os.path.basename(in_gdb) myzip = zipfile.ZipFile(os.path.join(root_dir, out_file_name), 'w', zipfile.ZIP_DEFLATED) for folder, subfolder, file in os.walk( os.path.join(root_dir, gdb_name)): for each in subfolder + file: source = os.path.join(folder, each) if not source.endswith(".lock"): # remove the absolute path to compose arcname # also handles the remaining leading path separator with lstrip arcname = source[len(root_dir):].lstrip(os.sep) # write the file under a different name in the archive myzip.write(source, arcname=arcname) myzip.close() def zip_folder(in_folder, out_file_name): myzip = zipfile.ZipFile(os.path.join(in_folder, out_file_name), 'w', zipfile.ZIP_DEFLATED) for folder, subfolder, file in os.walk(in_folder): for each in subfolder + file: source = os.path.join(folder, each) # remove the absolute path to compose arcname # also handles the remaining leading path separator with lstrip arcname = source[len(in_folder):].lstrip(os.sep) # write the file under a different name in the archive myzip.write(source, arcname=arcname) myzip.close() # TODO: do something with folder-based file structures. ex: GDB .... user the zipper_folder_structure() function above. from arcpy import AddMessage files_in_dir = [] for root, dirs, files in os.walk(in_directory): for filename in files: files_in_dir.append([root, filename]) file_name_list = [] files_to_zip = [] for f in files_in_dir: root = f[0] filename = f[1] file = os.path.join(root, filename) file_partitioned = filename.partition('.')[0] if file_partitioned not in file_name_list: if len(files_to_zip) > 1: out_file_path = files_to_zip[0].replace( in_directory, out_directory).partition('.')[0] zipper(files_to_zip, out_file_path) AddMessage(files_to_zip) files_to_zip = [] file_name_list.append(file_partitioned) else: files_to_zip.append(file) # If last file in directory for processing if root == files_in_dir[-1][0] and filename == files_in_dir[ -1][1]: out_file_path = files_to_zip[0].replace( in_directory, out_directory).partition('.')[0] zipper(files_to_zip, out_file_path) # Check back in Image Analyst license CheckInExtension("ImageAnalyst") except LicenseError: AddError("ImageAnalyst license is unavailable") print("ImageAnalyst license is unavailable") except ExecuteError: AddError(GetMessages(2)) print(GetMessages(2))
def reviewData(): try: print("Starting the Data Reviewer batch job at:\n" + str(reviewerBatchJob) + ".") print("For the data located in:\n" + str(workspaceToReview) + ".") print( "If one of the feature classes, Routes or CalPts, does not exist in the place that the" ) print( "data reviewer batch job looks for it, then you will get an 'Unknown Error'." ) print( "This can be remedied by updating the data reviewer batch job's workspace settings." ) # Test the data reviewer part: if CheckExtension("datareviewer") == 'Available': print("Extension availability check complete.") CheckOutExtension("datareviewer") # Checking to see if the output already exists. # If so, remove it so that it can be recreated. -- For the errors, might need a better process, so that # it's possible to track where the errors were at the start and how things progressed. if Exists(reviewerSessionGDB): Delete_management(reviewerSessionGDB) else: pass # Create new geodatabase # Replace with returnGDBOrSDEPath(reviewerSessionGDB), returnGDBOrSDEName(reviewerSessionGDB) # or similar functions CreateFileGDB_management(reviewerSessionGDBFolder, returnGDBOrSDEName(reviewerSessionGDB)) # Execute EnableDataReviewer EnableDataReviewer_Reviewer(reviewerSessionGDB, "#", "#", "DEFAULTS") # Create a new Reviewer session ##CreateReviewerSession_Reviewer (reviewer_workspace, session_name, {session_template}, {duplicate_checking}, {store_geometry}, {username}, {version}) CreateReviewerSession_Reviewer(reviewerSessionGDB, reviewerSession, "", "NONE", "STORE_GEOMETRY") # execute the batch job batchJobResult = ExecuteReviewerBatchJob_Reviewer( reviewerSessionGDB, sessionReviewerSession, reviewerBatchJob, workspaceToReview) print("Data Reviewer batch job complete.") # get the output table view from the result object outputTable = batchJobResult.getOutput(0) print("The output table is called " + str(outputTable.name) + "." ) # prints REVBATCHRUNTABLE CheckInExtension("datareviewer") else: print( "The 'datareviewer' extension is not available. Skipping checks." ) except Exception as Exception1: # If an error occurred, print line number and error message import traceback, sys tb = sys.exc_info()[2] print "Line %i" % tb.tb_lineno print Exception1.message try: del Exception1 except: pass finally: CheckInExtension("datareviewer")
Name: Urban Water Analysis Conventional analysis Purpose: find buildings covered by distance and elevation Project: language for spatial computing Author: ICRC (2017), adapted by Selina Studer License: Apache License 2.0 Created: 26.12.2018 Libraries: arcpy -------------------------------------------------------------------------------""" from arcpy import CheckOutExtension, env, SelectLayerByLocation_management, FeatureToPoint_management, CopyFeatures_management, JoinField_management, SelectLayerByAttribute_management from arcpy.sa import ExtractValuesToPoints from arcpy.da import SearchCursor env.overwriteOutput = True CheckOutExtension("Spatial") # load input data area = 'C:/area.shp' dem = 'C:/dem.tif' waterPoint = 'C:/waterPoints.shp' building = 'C:/buildings.shp' # set parameters distance = 50 elevation = 3 # select water points within area waterPoint_inArea = SelectLayerByLocation_management(waterPoint, 'INTERSECT', area)
def process(): class LicenseError(Exception): pass try: if CheckExtension("3D") == "Available": CheckOutExtension("3D") else: # raise a custom exception raise LicenseError # Constants - DO NOT MODIFY split_area = "split_area" orig_area = "orig_area" def calc_area(in_fc, field_name): AddField(in_fc, field_name, "DOUBLE") with da.UpdateCursor(in_fc, [field_name, "SHAPE@AREA"]) as cursor1: for r1 in cursor1: r1[0] = r1[1] cursor1.updateRow(r1) def field_exists(in_fc, in_field): from arcpy import ListFields if in_field in [f.name for f in ListFields(in_fc)]: return True else: return False def delete_field_if_exists(in_fc, in_field): if field_exists(in_fc, in_field): DeleteField(in_fc, in_field) assert field_exists(in_buildings, building_fid), \ "no attribute named {} in feature class".format(building_fid) for field in [tile_fid, file_name]: delete_field_if_exists(in_buildings, field) temp_fp = join("in_memory", "mp_fp") ddd.MultiPatchFootprint(in_buildings, temp_fp, "bldg_fid") calc_area(in_fc=temp_fp, field_name=orig_area) temp_isect = join("in_memory", "temp_isect") Intersect(r"{0} #;{1} #".format(temp_fp, in_tiles), temp_isect, "ALL", None, "INPUT") # Delete Temporary Multipatch Footprint Delete(temp_fp) calc_area(in_fc=temp_isect, field_name=split_area) temp_isect_asc = join("in_memory", "temp_isect_asc") Sort(temp_isect, temp_isect_asc, [[building_fid, "ASCENDING"]]) # Delete Temporary Intersect Feature Class Delete(temp_isect) fields = [building_fid, tile_fid, file_name, orig_area, split_area] # Generate a list of duplicates bldg_list = [] with da.SearchCursor(temp_isect_asc, building_fid) as cursor2: for row in cursor2: bldg_list.append(row[0]) duplicates = [ item for item, count in Counter(bldg_list).items() if count > 1 ] duplicates_list = [] for i in duplicates: duplicates_list.append([i, bldg_list.count(i)]) # TODO: Resolve why tile_fid is not showing up below when BuildingFID and TileFID are OID fields. "In_memory" issue ''' # \\ Begin Debug print code from arcpy import AddMessage fds = [f.name for f in arcpy.ListFields(temp_isect_asc) if f.name in fields] AddMessage(fds) nfds = [f.name for f in arcpy.ListFields(temp_isect_asc) if f.name not in fields] AddMessage(nfds) # End Debug pring code // ''' final_list = [] with da.SearchCursor(temp_isect_asc, fields) as cursor3: prev_area = -1 prev_item_list = [] item_count = 0 fcound = 0 for row in cursor3: if row[0] not in duplicates: final_list.append([row[0], row[1], row[2]]) else: area = row[3] - row[4] index = duplicates.index(row[0]) total_items = duplicates_list[index][1] if row[0] == duplicates[ 0] and item_count == 0: # Deal with first item differently item_count += 1 prev_area = area prev_item_list = [row[0], row[1], row[2]] elif item_count + 1 == total_items: # Deal with last item in list if prev_area <= area: prev_area = area prev_item_list = [row[0], row[1], row[2]] final_list.append(prev_item_list) item_count = 0 prev_area = -1 prev_item_list = [] elif item_count + 1 != total_items: if prev_area <= area: prev_area = area prev_item_list = [row[0], row[1], row[2]] item_count += 1 # Append results back to Input Feature Class AddField(in_buildings, tile_fid, "LONG") AddField(in_buildings, file_name, "TEXT") with da.UpdateCursor(in_buildings, [building_fid, tile_fid, file_name]) as cursor: for r in cursor: for i in final_list: if r[0] == i[0]: r[1] = int(i[1]) r[2] = str(i[2]) cursor.updateRow(r) Delete(temp_isect) del bldg_list del duplicates_list del duplicates # Check back in 3D Analyst license CheckInExtension("3D") except LicenseError: AddError("3D Analyst license is unavailable") print("3D Analyst license is unavailable") except ExecuteError: AddError("3D Analyst license is unavailable") print(GetMessages(2))
def main(): """ Runs the centrality tool. """ env.overwriteOutput = True # Enable overwritting CheckOutExtension("Network") # Success of the program through the six steps success = True # Inputs to the tool if len(argv) != INPUT_COUNT + 1: raise Exception("Invalid number of inputs") input_number = index() input_number.next() # Skip over sys.argv[0] inputs = {} inputs[INPUT_BUILDINGS] = argv[input_number.next()] inputs[POINT_LOCATION] = ("INSIDE" if argv[input_number.next()] == "true" else "CENTROID") inputs[INPUT_NETWORK] = argv[input_number.next()] inputs[COMPUTE_REACH] = argv[input_number.next()] == "true" inputs[COMPUTE_GRAVITY] = argv[input_number.next()] == "true" inputs[COMPUTE_BETWEENNESS] = argv[input_number.next()] == "true" inputs[COMPUTE_CLOSENESS] = argv[input_number.next()] == "true" inputs[COMPUTE_STRAIGHTNESS] = argv[input_number.next()] == "true" inputs[ID_ATTRIBUTE] = argv[input_number.next()] inputs[NODE_WEIGHT_ATTRIBUTE] = argv[input_number.next()] inputs[IMPEDANCE_ATTRIBUTE] = argv[input_number.next()] try: inputs[SEARCH_RADIUS] = float(argv[input_number.next()]) except: inputs[SEARCH_RADIUS] = INFINITE_RADIUS inputs[USE_NETWORK_RADIUS] = (argv[input_number.next()] == ON_THE_NETWORK_OPTION) try: inputs[BETA] = float(argv[input_number.next()]) except: raise Invalid_Input_Exception("Beta") inputs[NORMALIZE_RESULTS] = [measure for measure in argv[input_number.next()].split(";") if measure != "#"] inputs[OUTPUT_LOCATION] = argv[input_number.next()] inputs[OUTPUT_FILE_NAME] = argv[input_number.next()] inputs[ACCUMULATOR_ATTRIBUTES] = argv[input_number.next()] # Record the origin nodes for centrality measurements # This is important if the user selects a subset of the features to be origins selected_features = all_values_in_column(inputs[INPUT_BUILDINGS], inputs[ID_ATTRIBUTE]) # Clear selection if we got a layer file try: SelectLayerByAttribute_management(inputs[INPUT_BUILDINGS], "CLEAR_SELECTION") except: pass # Adjacency List table name node_locations_needed = (inputs[COMPUTE_STRAIGHTNESS] or not inputs[USE_NETWORK_RADIUS]) adj_dbf_name = ("%s_%s_%s_%s_%s_%s.dbf" % (ADJACENCY_LIST_NAME, basename(inputs[INPUT_BUILDINGS]), basename(inputs[INPUT_NETWORK]), inputs[ID_ATTRIBUTE], inputs[IMPEDANCE_ATTRIBUTE], inputs[ACCUMULATOR_ATTRIBUTES])).replace("#", "None") if len(adj_dbf_name) > MAX_FILE_NAME_LENGTH: AddWarning(WARNING_LARGE_ADJ_FILE_NAME) adj_dbf = join(inputs[OUTPUT_LOCATION], adj_dbf_name) # Output file names output_feature_class_name = feature_class_name(inputs[OUTPUT_FILE_NAME]) output_feature_class = "%s.shp" % join(inputs[OUTPUT_LOCATION], output_feature_class_name) # Create a feature class that is a copy of the input buildings try: AddMessage(INPUT_BUILDINGS_COPY_STARTED) CreateFeatureclass_management(out_path=inputs[OUTPUT_LOCATION], out_name=output_feature_class_name) CopyFeatures_management(in_features=inputs[INPUT_BUILDINGS], out_feature_class=output_feature_class) AddMessage(INPUT_BUILDINGS_COPY_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(INPUT_BUILDINGS_COPY_FAILED) success = False output_layer_name = layer_name(inputs[OUTPUT_FILE_NAME]) output_layer = "%s.lyr" % join(inputs[OUTPUT_LOCATION], output_layer_name) # If output has already been created, don't carry on if Exists(output_layer): AddWarning(WARNING_OUTPUT_ALREADY_EXISTS) success = False # We will convert polygon input buildings to point feature class buildings_description = Describe(output_feature_class) if buildings_description.shapeType == "Point": # Input buildings are already a point shape file inputs[INPUT_POINTS] = output_feature_class elif buildings_description.shapeType == "Polygon": # Input buildings need to be converted to point feature class point_feature_class_name = POINT_FEATURE_CLASS_NAME( basename(output_feature_class), inputs[POINT_LOCATION]) inputs[INPUT_POINTS] = "%s.shp" % join(inputs[OUTPUT_LOCATION], point_feature_class_name) # If FID is used as ID attribute, we need to change it since a point # shapefile will be in use if inputs[ID_ATTRIBUTE] == "FID": inputs[ID_ATTRIBUTE] = ORIGINAL_FID else: # Input buildings need to be either points or polygons raise Invalid_Input_Exception("Input Buildings") # Find the appropriate symbology layer for metric_index in range(len(METRICS)): if inputs[COMPUTE_REACH + metric_index]: first_metric = METRICS[metric_index] break symbology_layer_name = get_symbology_layer_name( buildings_description.shapeType, first_metric) symbology_layer = join(SYMBOLOGY_DIR, symbology_layer_name) def clean_up(): """ Removes all auxiliary files """ auxiliary_dir = join(inputs[OUTPUT_LOCATION], AUXILIARY_DIR_NAME) od_cost_matrix_layer = join(auxiliary_dir, OD_COST_MATRIX_LAYER_NAME) od_cost_matrix_lines = join(auxiliary_dir, OD_COST_MATRIX_LINES) temp_adj_dbf_name = "%s~.dbf" % adj_dbf_name[-4] temp_adj_dbf = join(inputs[OUTPUT_LOCATION], temp_adj_dbf_name) partial_adj_dbf = join(auxiliary_dir, PARTIAL_ADJACENCY_LIST_NAME) polygons = join(auxiliary_dir, POLYGONS_SHAPEFILE_NAME) raster = join(auxiliary_dir, RASTER_NAME) polygons_layer = join(auxiliary_dir, POLYGONS_LAYER_NAME) input_points_layer = join(auxiliary_dir, INPUT_POINTS_LAYER_NAME) for delete_path in [input_points_layer, polygons_layer, raster, polygons, partial_adj_dbf, temp_adj_dbf, od_cost_matrix_lines, od_cost_matrix_layer, auxiliary_dir]: delete(delete_path) try: """ Here we carry out the six steps of the tool """ # Step 1 if success: AddMessage(STEP_1_STARTED) # If necessary, convert input buildings to point feature class if buildings_description.shapeType == "Polygon": AddMessage(POINT_CONVERSION_STARTED) to_point_feature_class(output_feature_class, inputs[INPUT_POINTS], inputs[POINT_LOCATION]) AddMessage(POINT_CONVERSION_FINISHED) if Exists(adj_dbf): AddMessage(ADJACENCY_LIST_COMPUTED) if node_locations_needed: calculate_network_locations(inputs[INPUT_POINTS], inputs[INPUT_NETWORK]) AddMessage(STEP_1_FINISHED) else: try: compute_adjacency_list(inputs[INPUT_POINTS], inputs[INPUT_NETWORK], inputs[ID_ATTRIBUTE], inputs[IMPEDANCE_ATTRIBUTE], inputs[ACCUMULATOR_ATTRIBUTES], inputs[SEARCH_RADIUS], inputs[OUTPUT_LOCATION], adj_dbf_name) AddMessage(STEP_1_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(STEP_1_FAILED) success = False # Step 2 if success: AddMessage(STEP_2_STARTED) try: distance_field = trim("Total_%s" % inputs[IMPEDANCE_ATTRIBUTE]) accumulator_fields = set([trim("Total_%s" % accumulator_attribute) for accumulator_attribute in inputs[ACCUMULATOR_ATTRIBUTES].split( ";") if accumulator_attribute != "#"]) # Graph representation: dictionary mapping node id's to Node objects nodes = {} # The number of rows in |adj_dbf| directed_edge_count = int(GetCount_management(adj_dbf).getOutput(0)) graph_progress = Progress_Bar(directed_edge_count, 1, STEP_2) rows = UpdateCursor(adj_dbf) for row in rows: # Get neighboring nodes, and the distance between them origin_id = row.getValue(trim(ORIGIN_ID_FIELD_NAME)) destination_id = row.getValue(trim(DESTINATION_ID_FIELD_NAME)) distance = float(row.getValue(distance_field)) # Make sure the nodes are recorded in the graph for id in [origin_id, destination_id]: if not id in nodes: nodes[id] = Node() # Make sure that the nodes are neighbors in the graph if origin_id != destination_id and distance >= 0: accumulations = {} for field in accumulator_fields: accumulations[field] = float(row.getValue(field)) nodes[origin_id].add_neighbor(destination_id, distance, accumulations) nodes[destination_id].add_neighbor(origin_id, distance, accumulations) graph_progress.step() N = len(nodes) # The number of nodes in the graph if N == 0: AddWarning(WARNING_NO_NODES) success = False AddMessage(STEP_2_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(STEP_2_FAILED) success = False # Step 3 if success: AddMessage(STEP_3_STARTED) try: get_weights = inputs[NODE_WEIGHT_ATTRIBUTE] != "#" get_locations = node_locations_needed # Keep track of number nodes in input points not present in the graph point_not_in_graph_count = 0 input_point_count = int( GetCount_management(inputs[INPUT_POINTS]).getOutput(0)) node_attribute_progress = Progress_Bar(input_point_count, 1, STEP_3) rows = UpdateCursor(inputs[INPUT_POINTS]) for row in rows: id = row.getValue(inputs[ID_ATTRIBUTE]) if not id in nodes: point_not_in_graph_count += 1 continue if get_weights: setattr(nodes[id], WEIGHT, row.getValue(trim(inputs[NODE_WEIGHT_ATTRIBUTE]))) if get_locations: snap_x = row.getValue(trim("SnapX")) snap_y = row.getValue(trim("SnapY")) setattr(nodes[id], LOCATION, (snap_x, snap_y)) node_attribute_progress.step() if point_not_in_graph_count: AddWarning(WARNING_POINTS_NOT_IN_GRAPH(N, point_not_in_graph_count)) AddMessage(STEP_3_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(STEP_3_FAILED) success = False # Step 4 if success: AddMessage(STEP_4_STARTED) try: # Compute measures compute_centrality(nodes, selected_features, inputs[COMPUTE_REACH], inputs[COMPUTE_GRAVITY], inputs[COMPUTE_BETWEENNESS], inputs[COMPUTE_CLOSENESS], inputs[COMPUTE_STRAIGHTNESS], inputs[SEARCH_RADIUS], inputs[USE_NETWORK_RADIUS], inputs[BETA], inputs[NORMALIZE_RESULTS], accumulator_fields) AddMessage(STEP_4_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(STEP_4_FAILED) success = False # Step 5 if success: AddMessage(STEP_5_STARTED) try: # Make output layer MakeFeatureLayer_management(in_features=output_feature_class, out_layer=output_layer_name) # Save output layer SaveToLayerFile_management(output_layer_name, output_layer, "ABSOLUTE") # Use a test node to figure out which metrics were computed test_node_id = selected_features.pop() # Make sure the test node is in the graph while test_node_id not in nodes: test_node_id = selected_features.pop() test_node = nodes[test_node_id] measures = set([measure for measure in dir(test_node) if (measure in FINAL_ATTRIBUTES or is_accumulator_field(measure))]) # Add a field in the output layer for each computed metric for measure in measures: AddField_management(in_table=output_layer, field_name=trim(measure), field_type="DOUBLE", field_is_nullable="NON_NULLABLE") # Figure out the id field to use based on the type of input buildings if (buildings_description.shapeType == "Polygon" and inputs[ID_ATTRIBUTE] == ORIGINAL_FID): id_field = "FID" else: id_field = inputs[ID_ATTRIBUTE] # Fill the layer with the metric values write_progress = Progress_Bar(N, 1, STEP_5) layer_rows = UpdateCursor(output_layer) for row in layer_rows: id = row.getValue(id_field) for measure in measures: # If no value was computed for this node id, set value to 0 value = 0 if id in nodes and hasattr(nodes[id], measure): value = getattr(nodes[id], measure) row.setValue(trim(measure), value) layer_rows.updateRow(row) write_progress.step() # Save to toolbox output SetParameterAsText(OUTPUT_FEATURE_CLASS, output_feature_class) AddMessage(STEP_5_FINISHED) except: AddWarning(GetMessages(2)) AddMessage(STEP_5_FAILED) success = False # Step 6 if success: AddMessage(STEP_6_STARTED) # Apply symbology try: ApplySymbologyFromLayer_management(in_layer=output_layer, in_symbology_layer=symbology_layer) except: AddWarning(WARNING_APPLY_SYMBOLOGY_FAILED) AddWarning(GetMessages(2)) AddMessage(STEP_6_FAILED) # Display try: current_map_document = mapping.MapDocument("CURRENT") data_frame = mapping.ListDataFrames(current_map_document, "Layers")[0] add_layer = mapping.Layer(output_layer) mapping.AddLayer(data_frame, add_layer, "AUTO_ARRANGE") AddMessage(STEP_6_FINISHED) except: AddWarning(WARNING_FAIL_TO_DISPLAY) AddWarning(GetMessages(2)) AddMessage(STEP_6_FAILED) # Clean up clean_up() AddMessage(SUCCESS if success else FAILURE) except ExecuteAbort: clean_up()
""""---------------------------------------------------------------------------- Name: coreconcepts.py Purpose: coreconcepts library Project: language for spatial computing Author: Kuhn et al. 2018, adapted by Selina Studer License: Apache License 2.0 Created: 26.12.2018 Libraries: arcpy -----------""" from arcpy import CheckOutExtension, env env.overwriteOutput = True # Check out any necessary licenses CheckOutExtension("spatial") class CcField(object): """ Abstract class for core concept 'field' """ def __init__(self, filepath, objIndex, domain): """ :param filepath: data file path :param objIndex: unique ID :param domain: desc.extent of the geo_object """ self.filepath = filepath self.sObj = objIndex self.domain = domain
from Constants import WEIGHT from Node import Node from os.path import join from sys import argv from Utils import all_values_in_column from Utils import basename from Utils import calculate_network_locations from Utils import delete from Utils import Invalid_Input_Exception from Utils import is_accumulator_field from Utils import Progress_Bar from Utils import to_point_feature_class from Utils import trim env.overwriteOutput = True # Enable overwritting CheckOutExtension("Network") # Success of the program through the six steps success = True # Inputs to the tool if len(argv) != INPUT_COUNT + 1: raise Exception("Invalid number of inputs") input_number = index() input_number.next() # Skip over sys.argv[0] inputs = {} inputs[INPUT_BUILDINGS] = argv[input_number.next()] inputs[POINT_LOCATION] = ("INSIDE" if argv[input_number.next()] == "true" else "CENTROID") inputs[INPUT_NETWORK] = argv[input_number.next()] inputs[COMPUTE_REACH] = argv[input_number.next()] == "true"
def main(): from arcpy import CheckExtension, CheckOutExtension, CheckInExtension, ExecuteError, GetMessages, AddError,\ ListDatasets, env, SetProgressor, SetProgressorLabel, SetProgressorPosition, ResetProgressor, Exists from arcpy.management import CreateFileGDB, CreateMosaicDataset, AddRastersToMosaicDataset from arcpy import Describe from os.path import join, exists from os import mkdir, makedirs class LicenseError(Exception): pass try: if CheckExtension("ImageAnalyst") == "Available": CheckOutExtension("ImageAnalyst") else: # raise a custom exception raise LicenseError try: from PIL import Image except ModuleNotFoundError: AddError( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) print( "PILLOW Library Not Detected. Install using Python Manager in ArcGIS Pro" ) exit() env.workspace = in_mosaic_gdb mosaics = ListDatasets("*", "Mosaic") file_count = len(mosaics) count = 0 SetProgressor("step", "Begin Processing Files...", 0, file_count, 1) if not exists(out_folder): makedirs(out_folder) fileGDB = join(out_folder, "ortho_mosaics.gdb") if not Exists(fileGDB): CreateFileGDB(out_folder, "ortho_mosaics.gdb") for mosaic in mosaics: print("processing mosaic {0} of {1}".format(count + 1, file_count)) in_mosaic = join(in_mosaic_gdb, mosaic) i_list, extent = get_images_and_stats( in_mosaic ) # Obtain image statistics and info from mosaic for processing for i in i_list: # Check that output folder is not the path of i if out_folder == path.dirname(i[0]): AddError( "outFolder cannot be the same folder/directory as images referenced in the mosaic dataset" ) exit() if not path.exists(out_folder): makedirs(out_folder) out_tile_folder = join(out_folder, "tiles{}".format(count)) mkdir(out_tile_folder) SetProgressorLabel("Texturing Mosaic {0}...".format(count)) texture_images(i_list, extent, in_texture, in_polygon, out_tile_folder, method, blur_distance) # Generate Texture-Masked tiles mosaic_name = "tiles{}_".format(count) mosaic_dataset = join(fileGDB, mosaic_name) SetProgressorLabel( "Creating Mosaic Dataset for Tiles of {0}...".format(mosaic)) sr = Describe(in_mosaic).spatialReference CreateMosaicDataset(fileGDB, mosaic_name, sr, num_bands, pixel_depth, product_definition, product_band_definitions) SetProgressorLabel( "Adding of {0} to Mosaic Dataset...".format(mosaic)) AddRastersToMosaicDataset(mosaic_dataset, "Raster Dataset", out_tile_folder, "UPDATE_CELL_SIZES", "UPDATE_BOUNDARY", "NO_OVERVIEWS", None, 0, 1500, None, '', "SUBFOLDERS", "ALLOW_DUPLICATES", "NO_PYRAMIDS", "NO_STATISTICS", "NO_THUMBNAILS", '', "NO_FORCE_SPATIAL_REFERENCE", "NO_STATISTICS", None, "NO_PIXEL_CACHE") SetProgressorPosition() count += 1 ResetProgressor() CheckInExtension("ImageAnalyst") except LicenseError: AddError("Image Analyst license is unavailable") print("Image Analyst license is unavailable") except ExecuteError: print(GetMessages(2))