def execute(self, parameters, messages): rasteri = arcpy.Raster(parameters[0].valueAsText) arcpy.env.overwriteOutput = True lowervalue = parameters[1].value uppervalue = parameters[2].value nodatathreshold = parameters[3].value output_rastername = parameters[4].valueAsText addtomap = parameters[5].value ignorenegative = parameters[6].value raster_array = arcpy.RasterToNumPyArray(rasteri) #, nodata_to_value=0); super_threshold_indices = raster_array < nodatathreshold raster_array[super_threshold_indices] = numpy.nan #myprint (str(raster_array[0][0])) myprint("\n" + "=" * 10 + " Rescale raster " + "=" * 10) myprint("Starting rescale raster") minimi = numpy.nanmin(raster_array) maksimi = numpy.nanmax(raster_array) if (ignorenegative): myprint(" Negatives will be changed to zero...") raster_array[raster_array < 0] = 0 raster_array[raster_array < 0] = 0 myprint(" ...done") else: minimi = numpy.nanmin(raster_array) if (minimi < 0): myprint(" Negatives will be spread to new raster Min: %s" % (str(minimi))) raster_array += numpy.abs(minimi) #myprint (str(raster_array)); diff = uppervalue - lowervalue myprint(" Rescaling array[%s - %s] -> array[%s .. %s] " % (str(minimi), str(maksimi), str(lowervalue), str(uppervalue))) myprint(" max(raster_array):%s diff:%s" % (str(numpy.nanmax(raster_array)), str(diff))) raster_array = (raster_array / (float( (numpy.nanmax(raster_array)))) * diff) raster_array = raster_array + lowervalue #myprint (str(raster_array[0][0])) myprint("Calculation done.") #myprint (str(raster_array)); mx = rasteri.extent.XMin + 0 * rasteri.meanCellWidth my = rasteri.extent.YMin + 0 * rasteri.meanCellHeight #myprint ( "Size of output raster: %s x %s"%( numpy.shape(numero4),numpy.shape(uusi))); #myprint (uusi[100]); # Overwrite arcpy.env.overwriteOutput = True myRasterBlock = arcpy.NumPyArrayToRaster(raster_array, arcpy.Point(mx, my), rasteri.meanCellWidth, rasteri.meanCellHeight) myprint("Saving new raster...\n Output rastername: %s" % (output_rastername)) #myRasterBlock.save("d:\\arcgis\\database.gdb\\tulos"); myRasterBlock.save(output_rastername) desc = arcpy.Describe(output_rastername) name = desc.file.split('.')[0] + "_layer" #parameters[3].value = myRasterBlock; if (addtomap): myprint(" Adding layer to map with name: " + name) addToDisplay(output_rastername, name, "TOP")
def create_GLADseamask(in_gladtile, in_mod44w, in_alositerator, in_lakes, outpath, processgdb): """ Identifies sea/ocean water pixels in a GLAD surface water classes tile :param in_gladtile: path to GLAD tile to be processed :param in_mod44w: path of extracted and mosaicked MOD44W C6 QA layer envelopping GLAD tile :param in_alositerator: list of dictionary that contains extents of intersecting ALOS DEM tiles :return: GLAD tile with same extent and pixel size but where sea water pixels are identified as class 9 """ gladtileid = 'glad{}'.format( re.sub( '(^.*class99_1[89]_)|([.]tif)', '', gladtile)) # Unique identifier for glad tile based on coordinates gladtile_extent = arcpy.Describe(gladtile).extent mod44w_outdir = os.path.split(in_mod44w)[0] print('Creating seamask for {}...'.format(gladtileid)) # Run a 3x3 majority filter on MODIS to get rid of isolated sea pixels modmaj = os.path.join(mod44w_outdir, 'mod44wmaj_{}'.format(gladtileid)) print(' 1/15 - Majority filter of MODIS QA layer...') if not arcpy.Exists(modmaj): focallyr = FocalStatistics(in_raster=in_mod44w, neighborhood=NbrRectangle(4, 4, "CELL"), statistics_type='MAJORITY') Con(IsNull(focallyr), Raster(in_mod44w), focallyr).save(modmaj) # Project, adjust cell size, and snap MODIS to GLAD tile print(' 2/15 - Project and resample MODIS to match GLAD tile...') arcpy.env.snapRaster = in_gladtile arcpy.env.extent = in_gladtile mod44w_gladmatch_wgs = os.path.join( mod44w_outdir, 'mod44wQA_glad{}_wgs'.format(gladtileid)) if not arcpy.Exists(mod44w_gladmatch_wgs): # try: # arcpy.Delete_management(mod44w_gladmatch_wgs) # except: # traceback.print_exc() arcpy.ProjectRaster_management( modmaj, out_raster=mod44w_gladmatch_wgs, in_coor_system=arcpy.Describe(in_mod44w).SpatialReference, out_coor_system=arcpy.SpatialReference( 4326), #WGS84, same as in_gladtile, cell_size=arcpy.Describe(in_gladtile).meanCellWidth, resampling_type='NEAREST') # ----------- Format ALOS ---------------------------------------------------------------------------------------------- # Subset tiles to only keep those that intersect the GLAD tile print(' 3/15 - Getting intersecting ALOS DEM tiles...') alos_seltiles = get_inters_tiles(ref_extent=gladtile_extent, tileiterator=in_alositerator, containsonly=False) # Format ALOS alos_mosaictile = os.path.join(processgdb, 'alos_mosaic_{}'.format(gladtileid)) print(' 4/15 - Mosaicking ALOS DEM tiles...') if not arcpy.Exists(alos_mosaictile): arcpy.MosaicToNewRaster_management( input_rasters=alos_seltiles, output_location=os.path.split(alos_mosaictile)[0], # 'in_memory raster_dataset_name_with_extension=os.path.split(alos_mosaictile) [1], pixel_type='16_BIT_SIGNED', number_of_bands=1) alos_rsp = os.path.join(processgdb, 'alos_rsp{}'.format(gladtileid)) print(' 5/15 - Resampling ALOS DEM...') if not arcpy.Exists(alos_rsp): arcpy.Resample_management( in_raster=alos_mosaictile, out_raster=alos_rsp, cell_size=arcpy.Describe(in_gladtile).meanCellWidth, resampling_type='NEAREST') # ----------- Format HydroLAKES ------------------------------------------------------------ lakeras = os.path.join(processgdb, '{}_lakeras'.format(gladtileid)) print(' 6/15 - Rasterizing HydroLAKES...') if not arcpy.Exists(lakeras): arcpy.PolygonToRaster_conversion( in_features=in_lakes, value_field="Lake_type", out_rasterdataset=lakeras, cell_assignment='CELL_CENTER', cellsize=arcpy.Describe(in_gladtile).meanCellWidth) # ----------- Create seamask based on MODIS, ALOS, and GLAD ------------------------------------------------------------ # Create GLAD land-water mask print( ' 7/15 - Creating GLAD land-water mask, excluding known lake pixels from the analysis...' ) gladtile_mask = os.path.join(processgdb, '{}_mask'.format(gladtileid)) if not arcpy.Exists(gladtile_mask): arcpy.CopyRaster_management(in_raster=Con( IsNull(lakeras), Reclassify( in_gladtile, "Value", RemapValue([[0, "NoData"], [1, 1], [2, 2], [3, 2], [4, 2], [5, 2], [6, 2], [7, 2], [8, 2], [10, 1], [11, 2], [12, 0]])), 0), out_rasterdataset=gladtile_mask, pixel_type='4_BIT') # Prepare pixels that are water, under 0 m elevation and not already labeled as seamask by MOD44W for Nibbling gladtile_shore = os.path.join(processgdb, '{}_shore'.format(gladtileid)) # If seawater in MODIS seamask and water in GLAD: # 9 # else: # if elevation > 0 or land in glad: # glad values # else (i.e. <0 & water in glad): # NoData print( ' 8/15 - Creating shore mask to nibble on i.e. GLAD water, ' 'under 0 m elevation and not already labeled as seamask by MOD44W for Nibbling...' ) if not arcpy.Exists(gladtile_shore): Con((Raster(mod44w_gladmatch_wgs) == 4) & (Raster(gladtile_mask) == 2), 3, Con((Raster(alos_rsp) > 0) | (Raster(gladtile_mask) < 2), Raster(gladtile_mask))).save(gladtile_shore) # Expand seamask in contiguous areas < 0 meters in elevation and identified as water in GLAD print( ' 9/15 - Expanding seamask in contiguous areas <= 0 meters in elevation and identified as water in GLAD...' ) outnibble1 = os.path.join(processgdb, '{}_1nibble'.format(gladtileid)) if not arcpy.Exists(outnibble1): Nibble(in_raster=Raster(gladtile_shore), in_mask_raster=Raster(gladtile_shore), nibble_values='DATA_ONLY', nibble_nodata='PROCESS_NODATA', in_zone_raster=Con(IsNull(Raster(gladtile_shore)), 1, Con(Raster(gladtile_shore) == 3, 1, 0))).save(outnibble1) # Expand seamask by ten pixels in non-sea GLAD water pixels under 10 m in elevation outexpand = os.path.join(processgdb, '{}_expand'.format(gladtileid)) print( ' 10/15 - Expand seamask by ten pixels in non-sea GLAD water pixels...' ) # Another option is to constrain it at water under 10 m elevation but does not work under 10 m in elevation...') if not arcpy.Exists(outexpand): Con( (Raster(outnibble1) == 2), # & (Raster(alos_rsp)<10), Expand(in_raster=Raster(outnibble1), number_cells=10, zone_values=3), Raster(outnibble1)).save(outexpand) # Fill in remaining water pixels under 0 m elevation and not already labeled with nearest water value, whether inland or sea outnibble2 = os.path.join(processgdb, '{}_2nibble'.format(gladtileid)) print( ' 11/15 - Fill in remaining water pixels under 0 m elevation and' ' not already labeled with nearest water value, whether inland or sea...' ) if not arcpy.Exists(outnibble2): Nibble(in_raster=outexpand, in_mask_raster=outexpand, nibble_values='DATA_ONLY', nibble_nodata='PROCESS_NODATA', in_zone_raster=Raster(gladtile_mask) == 2).save(outnibble2) # Get regions outregion = os.path.join(processgdb, '{}_region'.format(gladtileid)) print(' 12/15 - Create regions out of contiguous areas...') if not arcpy.Exists(outregion): RegionGroup(in_raster=outnibble2, number_neighbors='FOUR', zone_connectivity='WITHIN', excluded_value=1).save(outregion) # Remove sea mask regions under 2000 pixels. This avoids having artefact patches surrounded by land or inland water outregionclean = os.path.join(processgdb, '{}_regionclean'.format(gladtileid)) print( ' 13/15 - Removing sea mask regions under 2000 pixels. ' 'This avoids having artefact patches surrounded by land or inland water...' ) if not arcpy.Exists(outregionclean): Con( IsNull(ExtractByAttributes(outregion, 'LINK = 3 AND Count > 2000')), gladtile_mask, 3).save(outregionclean) # Fill in inland water zones entirely surrounded by sea water outeuc = os.path.join(processgdb, '{}_euc'.format(gladtileid)) print( ' 14/15 - Filling in inland water zones entirely surrounded by sea water...' ) if not arcpy.Exists(outeuc): EucAllocation( in_source_data=InList(outregionclean, [0, 1, 3])).save(outeuc) outzone = os.path.join(processgdb, '{}_zone'.format(gladtileid)) if not arcpy.Exists(outzone): ZonalStatistics(in_zone_data=outregion, zone_field='Value', in_value_raster=outeuc, statistics_type='RANGE').save(outzone) print(' 15/15 - Creating final formatted GLAD tile with sea mask...') # #1. To deal with remaining NoData (< 0 elevation) # #2. There are NoData pixels that remain following the second nibble in areas where formerly water pixels have become # out of contact with any other water pixel. This carries into outregion and outzone, and so must be dealt with # in the last step # #3 all other pixels that have been identified as sea water if not arcpy.Exists(outpath): Con( IsNull(Raster(outregionclean)), in_gladtile, #1 Con( IsNull(outzone), in_gladtile, #2 Con( ((Raster(outzone) == 0) & (Raster(outeuc) == 3) & (Raster(outregionclean) == 2)) | ( #3 Raster(outregionclean) == 3), 9, in_gladtile))).save(outpath) arcpy.ClearEnvironment('extent') arcpy.ClearEnvironment('snapRaster') arcpy.ClearEnvironment('cellSize') arcpy.ClearEnvironment('mask')
def preprocess_x(input_fc, input_type, id_field, o_j_field, input_network, search_tolerance, search_criteria, search_query, travel_mode, batch_size): # add field mappings if input_type == "origins_i": field_mappings = arcpy.FieldMappings() field_mappings.addFieldMap(field_map_x(input_fc, id_field, "i_id")) if input_type == "destinations_j": field_mappings = arcpy.FieldMappings() field_mappings.addFieldMap(field_map_x(input_fc, id_field, "j_id")) field_mappings.addFieldMap(field_map_x(input_fc, o_j_field, "o_j")) # convert to points if required describe_x = arcpy.Describe(input_fc, input_type) if describe_x.ShapeType != "Point": arcpy.AddMessage("Converting " + input_type + " to points...") arcpy.management.FeatureToPoint(input_fc, r"in_memory/" + input_type + "_point", "INSIDE") arcpy.conversion.FeatureClassToFeatureClass( r"in_memory/" + input_type + "_point", r"in_memory", input_type, field_mapping=field_mappings) else: arcpy.AddMessage(input_type + " is already points...") arcpy.conversion.FeatureClassToFeatureClass( input_fc, r"in_memory", input_type, field_mapping=field_mappings) # prepare origins/destinations output if input_type == "origins_i": arcpy.management.AddField(r"in_memory/" + input_type, "i_id_text", "TEXT", field_length=255) arcpy.management.CalculateField(r"in_memory/" + input_type, "i_id_text", "!i_id!", "PYTHON3") output_fc = batch_i_setup(r"in_memory/" + input_type, batch_size) else: arcpy.management.AddField(r"in_memory/" + input_type, "j_id_text", "TEXT", field_length=255) arcpy.management.CalculateField(r"in_memory/" + input_type, "j_id_text", "!j_id!", "PYTHON3") layer = arcpy.management.MakeFeatureLayer(r"in_memory/" + input_type, input_type + "_view") arcpy.management.SelectLayerByAttribute(layer, "NEW_SELECTION", "o_j > 0") arcpy.conversion.FeatureClassToFeatureClass(layer, arcpy.env.workspace, input_type) output_fc = os.path.join(arcpy.env.workspace + "/" + input_type) # calculate network locations calculate_nax_locations(output_fc, input_type, input_network, search_tolerance, search_criteria, search_query, travel_mode) arcpy.AddMessage("Finished pre-processing " + input_type) arcpy.management.Delete(r"in_memory") return output_fc
def get_field(dataset, field_name): """ takes feature class and field name as input and return field object for the given field name""" return [f for f in arcpy.Describe(dataset).fields if f.name in field_name][0]
mode = "CAR" mu = car_fast sigma = car_fast_dev if transport_mode == 4: mode = "BIKE" mu = bike sigma = bike_dev if transport_mode == 5: mode = "WALK" mu = walk sigma = walk_dev print mode, mu, sigma #Get parameters spatial_ref = arcpy.Describe(line).spatialReference mem_point = arcpy.CreateFeatureclass_management("in_memory", "mem_point", "POINT", "", "DISABLED", "DISABLED", line) arcpy.AddField_management(mem_point, "LineOID", "LONG") arcpy.AddField_management(mem_point, "Value", "FLOAT") arcpy.AddField_management(mem_point, "COUNTID", "DOUBLE") #Set fields search_fields = ["SHAPE@", "OID@"] insert_fields = ["SHAPE@", "LineOID", "Value", "COUNTID"] #Access line and point with arcpy.da.SearchCursor(line, (search_fields)) as search: with arcpy.da.InsertCursor(mem_point, (insert_fields)) as insert: for row in search: try:
def Report_MODULE(PARAMS): """Report Generation""" start = time.clock() # start the clock message("Generating report...") # Report_PARAMS = [outTbl, siteName, mxd, pdf] outTbl = PARAMS[0] siteNameFld = str(PARAMS[1]) mxd = arcpy.mapping.MapDocument(PARAMS[2]) # Set file name, ext, and remove file if it already exists pdf = PARAMS[3] if os.path.splitext(pdf)[1] == "": pdf += ".pdf" if os.path.exists(pdf): os.remove(pdf) # Set path for intermediate pdfs pdf_path = os.path.dirname(pdf) + os.sep # Create the file and append pages in the cursor loop pdfDoc = arcpy.mapping.PDFDocumentCreate(pdf) graphic = "GRAPHIC_ELEMENT" blackbox = arcpy.mapping.ListLayoutElements(mxd, graphic, "blackbox")[0] graybox = arcpy.mapping.ListLayoutElements(mxd, graphic, "graybox")[0] # dictionary for field, type, ltorgt, numDigits, allnos, & average fld_dct = { 'field': [ 'FR_2_cnt', 'FR_3A_acr', 'FR_3A_boo', 'FR_3B_boo', 'FR_3B_sca', 'FR_3D_boo', 'V_2_50', 'V_2_100', 'V_2_score', 'V_2_boo', 'V_3A_boo', 'V_3B_scar', 'V_3C_comp', 'V_3D_boo', 'EE_2_cnt', 'EE_3A_boo', 'EE_3B_sca', 'EE_3C_boo', 'EE_3D_boo', 'R_2_03', 'R_2_03_tb', 'R_2_03_bb', 'R_2_05', 'R_2_6', 'R_3A_acr', 'R_3B_sc06', 'R_3B_sc1', 'R_3B_sc12', 'R_3C_boo', 'R_3D_boo', 'B_2_cnt', 'B_2_boo', 'B_3A_boo', 'B_3C_boo', 'B_3D_boo', 'Vul_High', 'Conserved' ] } txt, dbl = 'Text', 'Double' fld_dct['type'] = [ dbl, dbl, txt, txt, dbl, txt, dbl, dbl, dbl, txt, txt, dbl, dbl, txt, dbl, txt, dbl, txt, txt, dbl, txt, txt, dbl, dbl, dbl, dbl, dbl, dbl, txt, txt, dbl, txt, txt, txt, txt, dbl, dbl ] fld_dct['ltorgt'] = [ 'gt', 'gt', '', '', 'lt', '', 'gt', 'gt', 'gt', '', '', 'lt', 'gt', '', 'gt', '', 'lt', '', '', 'gt', '', '', 'gt', 'gt', 'gt', 'lt', 'lt', 'lt', '', '', 'gt', '', '', '', '', 'gt', 'gt' ] fld_dct['aveBool'] = [ '', '', 'YES', 'NO', '', 'YES', '', '', '', 'YES', 'YES', '', '', 'YES', '', 'YES', '', 'YES', 'YES', '', 'YES', 'YES', '', '', '', '', '', '', 'YES', 'YES', '', 'YES', 'YES', 'YES', 'YES', '', '' ] fld_dct['numDigits'] = [ 0, 2, 0, 0, 2, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2 ] fld_dct['rowNum'] = [ 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 39 ] fld_dct['allnos'] = [''] * 37 fld_dct['average'] = [''] * 37 # Make table layer from results table arcpy.MakeTableView_management(outTbl, "rptbview") desc = arcpy.Describe("rptbview") fieldInfo = desc.fieldInfo cnt_rows = str(arcpy.GetCount_management(outTbl)) for field in fld_dct['field']: # loop through fields idx = fld_dct['field'].index(field) # Check to see if field exists in results fldIndex = fieldInfo.findFieldByName(fld_dct['field'][idx]) if fldIndex > 0: # exists if fld_dct['type'][idx] == 'Text': # narrow to yes/no # Copy text field to list by field index fld_dct[idx] = field_to_lst(outTbl, field) # Check if all 'NO' if fld_dct[idx].count("NO") == int(cnt_rows): fld_dct['allnos'][idx] = 1 else: # type = Double l = [x for x in field_to_lst(outTbl, field) if x is not None] if l != []: # if not all null # Get average values fld_dct['average'][idx] = mean(l) start = exec_time(start, "loading data for report") i = 1 pg_cnt = 1 siterows = arcpy.SearchCursor(outTbl, "") # may be slow, use "rptbview"? siterow = siterows.next() while siterow: oddeven = i % 2 if oddeven == 1: column = 1 siteText = "SiteLeftText" site_Name = "SiteLeftName" else: column = 2 siteText = "SiteRightText" site_Name = "SiteRightName" TE = "TEXT_ELEMENT" siteText = arcpy.mapping.ListLayoutElements(mxd, TE, siteText)[0] siteText.text = "Site " + str(i) # Text element processing siteName = arcpy.mapping.ListLayoutElements(mxd, TE, site_Name)[0] fldNameValue = "siterow." + siteNameFld if fieldInfo.findFieldByName(siteNameFld) > 0: if eval(fldNameValue) == ' ': siteName.text = "No name" else: siteName.text = eval(fldNameValue) else: siteName.text = "No name" # loop through expected fields in fld_dct['field'] for field in fld_dct['field']: idx = fld_dct['field'].index(field) # Check to see if field exists in results # if it doesn't color = black if fldExists(field, column, fld_dct['rowNum'][idx], fieldInfo, blackbox): fldVal = "siterow." + field if fld_dct['type'][idx] == 'Double': # is numeric proctext(eval(fldVal), "Num", fld_dct['numDigits'][idx], fld_dct['ltorgt'][idx], fld_dct['average'][idx], column, fld_dct['rowNum'][idx], fld_dct['allnos'][idx], mxd) else: # is boolean proctext(eval(fldVal), "Boolean", 0, "", fld_dct['aveBool'][idx], column, fld_dct['rowNum'][idx], fld_dct['allnos'][idx], mxd) if oddeven == 0: exportReport(pdfDoc, pdf_path, pg_cnt, mxd) start = exec_time(start, "Page " + str(pg_cnt) + " generation") pg_cnt += 1 i += 1 siterow = siterows.next() # If you finish a layer with an odd number of records, # last record was not added to the pdf. if oddeven == 1: # Blank out right side siteText = arcpy.mapping.ListLayoutElements(mxd, "TEXT_ELEMENT", "SiteRightText")[0] siteText.text = " " # Fill right side with gray empty boxes for i in range(39): # Not set up to process the Social Equity or Reliability scores newBox = graybox.clone("_clone") boxpos(newBox, 2, i + 1) exportReport(pdfDoc, pdf_path, pg_cnt, mxd) del siterow del siterows arcpy.Delete_management("rptbview", "") pdfDoc.saveAndClose() mxd_result = os.path.splitext(pdf)[0] + ".mxd" if arcpy.Exists(mxd_result): arcpy.Delete_management(mxd_result) mxd.saveACopy(mxd_result) # save last page just in case del mxd del pdfDoc mxd_name = os.path.basename(mxd_result) message("Created PDF Report: {} and {}".format(pdf, mxd_name))
custum_trans = "dhdn3_utm_BW" #Textfile text = input_dir + "\zusammenfassung_shp.txt" outFile = open(text, "w") try: # Wandere durch Basisverzeichnis und alle seiner Sub-Verzeichnisse for (path, dirs, files) in os.walk(input_dir): # Schleife durch Dateien for shp in files: # Nur Shapfefiles berücksichtigen die zudem in DHDN3 vorliegen if shp.endswith(".shp") and ( arcpy.Describe(path + "\\" + shp).SpatialReference ).name == "DHDN_3_Degree_Gauss_Zone_3": print "Transformiere " + shp + " unter: " + path shp_utm = shp.replace(".", "_utm.") # ArcGIS Projektion mit spezifischer Transformationsmethode für BW arcpy.Project_management( path + "/" + shp, path + "/" + shp_utm, out_coor_system= "PROJCS['ETRS_1989_UTM_Zone_32N',GEOGCS['GCS_ETRS_1989',DATUM['D_ETRS_1989',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',9.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]", transform_method=custum_trans, in_coor_system= "PROJCS['DHDN_3_Degree_Gauss_Zone_3',GEOGCS['GCS_Deutsches_Hauptdreiecksnetz',DATUM['D_Deutsches_Hauptdreiecksnetz',SPHEROID['Bessel_1841',6377397.155,299.1528128]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Gauss_Kruger'],PARAMETER['False_Easting',3500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',9.0],PARAMETER['Scale_Factor',1.0],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]" )
import arcpy from arcpy import env env.workspace = r"C:\Users\Sheol\Desktop\2013-14\2015-2016\ProgramGIS\ArcPy\Lesson4" rasterlist = arcpy.ListRasters() for raster in rasterlist: desc = arcpy.Describe(raster) print raster + " is <<<" + desc.dataType + ">>> raster type"
def source(self, s): """ Validates source; can apply a fieldmap to an FC, also will copy locally if an external dataset :param s: :return: """ valid = True if type(s) is list: for path in s: if not arcpy.Exists(path): valid = False break else: if not arcpy.Exists(s): valid = False if not valid: logging.warning("Cannot find source {0!s}".format(s)) # If there's a field map, use it as an input to the FeatureClassToFeatureClass tool and copy the data locally if self.field_map: s = field_map.ini_fieldmap_to_fc(s, self.name, self.field_map, self.scratch_workspace) elif type(s) is list: # If we're dealing with a list (currently only GLAD and Terra-I, we can skip this validation) pass elif r"projects/wri-datalab" in s: pass # If there's not a field map, need to figure out what type of data source it is, and if it's local or not else: # This could be a folder, a gdb/mdb, a featuredataset, or an SDE database source_dirname = os.path.dirname(s) # we want to simply determine if this is local/not local so we can copy the datasource # first determine if our source dataset is within a featuredataset desc = arcpy.Describe(source_dirname) if hasattr(desc, "datasetType") and desc.datasetType == 'FeatureDataset': source_dirname = os.path.dirname(source_dirname) # Test if it's an SDE database try: server_address = arcpy.Describe( source_dirname).connectionProperties.server # If source SDE is localhost, don't need to worry about copying anywhere if server_address == 'localhost': pass else: s = util.copy_to_scratch_workspace(self.source, self.scratch_workspace) # Otherwise, just look at the drive letter to determine if it's local or not except AttributeError: # Split the drive from the path returns (Letter and :), then take only the letter and lower it drive = os.path.splitdrive(s)[0][0].lower() if drive in util.list_network_drives(): s = util.copy_to_scratch_workspace(self.source, self.scratch_workspace) elif drive not in ['c', 'd']: logging.info( "Are you sure the source dataset is local to this machine? \ It's not on drives C or D . . .") self._source = s
def writeDocument(sourceDataset, targetDataset, xmlFileName): desc = arcpy.Describe(sourceDataset) descT = arcpy.Describe(targetDataset) sourcePath = getLayerPath(desc) targetPath = getLayerPath(descT) ## Added May2016. warn user if capabilities are not correct, exit if not a valid layer if not dla.checkServiceCapabilities(sourcePath, False): dla.addMessage( sourceDataset + ' Does not appear to be a feature service layer, exiting. Check that you selected a layer not a service' ) return False if not dla.checkServiceCapabilities(targetPath, False): dla.addMessage( targetDataset + ' Does not appear to be a feature service layer, exiting. Check that you selected a layer not a service' ) return False xmlDoc = Document() root = xmlDoc.createElement('SourceTargetMatrix') xmlDoc.appendChild(root) root.setAttribute("version", '1.1') root.setAttribute("xmlns:esri", 'http://www.esri.com') dataset = xmlDoc.createElement("Datasets") root.appendChild(dataset) setSourceTarget(dataset, xmlDoc, "Source", sourcePath) setSourceTarget(dataset, xmlDoc, "Target", targetPath) setSpatialReference(dataset, xmlDoc, desc, "Source") setSpatialReference(dataset, xmlDoc, descT, "Target") setSourceTarget(dataset, xmlDoc, "ReplaceBy", "") fieldroot = xmlDoc.createElement("Fields") root.appendChild(fieldroot) fields = getFields(descT, targetDataset) sourceFields = getFields(desc, sourceDataset) sourceNames = [ field.name[field.name.rfind(".") + 1:] for field in sourceFields ] upperNames = [nm.upper() for nm in sourceNames] #try: for field in fields: fNode = xmlDoc.createElement("Field") fieldroot.appendChild(fNode) fieldName = field.name[field.name.rfind(".") + 1:] matchSourceFields(xmlDoc, fNode, field, fieldName, sourceNames, upperNames) # write the source field values setSourceFields(root, xmlDoc, sourceFields) setTargetFields(root, xmlDoc, fields) # Should add a template section for value maps, maybe write domains... # could try to preset field mapping and domain mapping... # add some data to the document writeDataSample(xmlDoc, root, sourceNames, sourceDataset, 10) # write it out xmlDoc.writexml(open(xmlFileName, 'w'), indent=" ", addindent=" ", newl='\n') xmlDoc.unlink()
currentOverwriteOutput = env.overwriteOutput env.overwriteOutput = True GCS_WGS_1984 = arcpy.SpatialReference(r"WGS 1984") webMercator = arcpy.SpatialReference( r"WGS 1984 Web Mercator (Auxiliary Sphere)") env.overwriteOutput = True scratch = env.scratchWorkspace #Project doesn't like in_memory featureclasses, copy to scratch copyInFeatures = os.path.join(scratch, "copyInFeatures") arcpy.CopyFeatures_management(inFeature, copyInFeatures) deleteme.append(copyInFeatures) prjInFeature = os.path.join(scratch, "prjInFeature") srInputPoints = arcpy.Describe(copyInFeatures).spatialReference arcpy.AddMessage("Projecting input points to Web Mercator ...") arcpy.Project_management(copyInFeatures, prjInFeature, webMercator) deleteme.append(prjInFeature) tempFans = os.path.join(scratch, "tempFans") if traversal < 360: # put bearing into 0 - 360 range geoBearing = math.fmod(geoBearing, 360.0) if debug == True: arcpy.AddMessage("geoBearing: " + str(geoBearing)) arithmeticBearing = Geo2Arithmetic( geoBearing ) # need to convert from geographic angles (zero north clockwise) to arithmetic (zero east counterclockwise) if debug == True: arcpy.AddMessage("arithmeticBearing: " + str(arithmeticBearing))
try: br = int(br) except: arcpy.AddError( "The script could not read your balance ratio because it is not a number" ) quit() print(br) try: minalt = int(minimum.split('.')[0]) except: minalt = int(minimum.split(',')[0]) minalt = minalt - interval desc = arcpy.Describe(dem) # Get information from the DEM nombre = os.path.join(files, desc.baseName + ".txt") # Get the name from the DEM # Create a .txt file and populate it with the data from the Surface volume # calculation, given the thresholds and the interval with open(nombre, "w") as f: try: for plane in range(minalt, maxalt, interval): result = arcpy.SurfaceVolume_3d(dem, "", "BELOW", plane) print(arcpy.GetMessage(0), file=f) print(arcpy.GetMessage(1), file=f) print(arcpy.GetMessage(2), file=f) print(arcpy.GetMessage(3), file=f) except Exception as e: print(e.message)
addMsgAndPrint(versionString) #test for valid input: # inFc exists and has item PlotAtScale if not arcpy.Exists(inFc): forceExit() fields = arcpy.ListFields(inFc) fieldNames = [] for field in fields: fieldNames.append(field.name) if not 'PlotAtScale' in fieldNames: arcpy.AddField_management(inFc, 'PlotAtScale', 'FLOAT') addMsgAndPrint('Adding field PlotAtScale to {}'.format(inFc)) gdb = os.path.dirname(inFc) if arcpy.Describe(gdb).dataType == 'FeatureDataset': gdb = os.path.dirname(gdb) if os.path.basename(inFc) == 'OrientationPoints': addMsgAndPrint('Populating OrientationPointsDicts') makeDictsOP(inFc) isOP = True else: isOP = False outTable = gdb + '/xxxPlotAtScales' testAndDelete(outTable) mapUnits = 'meters' minSeparationMapUnits = minSeparation_mm / 1000.0 searchRadius = minSeparationMapUnits * maxPlotAtScale if not 'meter' in arcpy.Describe(inFc).spatialReference.linearUnitName.lower():
def gen_cwd_back(core_list, climate_lyr, resist_lyr, core_lyr): """"Generate CWD and back rasters using r.walk in GRASS""" slope_factor = "1" walk_coeff_flat = "1" walk_coeff_uphill = str(cc_env.climate_cost) walk_coeff_downhill = str(cc_env.climate_cost * -1) walk_coeff = (walk_coeff_flat + "," + walk_coeff_uphill + "," + walk_coeff_downhill + "," + walk_coeff_downhill) focal_core_rast = "focal_core_rast" gcwd = "gcwd" gback = "gback" gbackrc = "gbackrc" core_points = "corepoints" no_cores = str(len(core_list)) # Map from directional degree output from GRASS to Arc's 1 to 8 directions # format. See r.walk source code and ArcGIS's 'Understanding cost distance # analysis' help page. rc_rules = "180=5\n225=4\n270=3\n315=2\n360=1\n45=8\n90=7\n135=6" try: for position, core_no in enumerate(core_list): core_no_txt = str(core_no) lm_util.gprint("Generating CWD and back rasters for Core " + core_no_txt + " (" + str(position + 1) + "/" + no_cores + ")") # Pull out focal core for cwd analysis write_grass_cmd("r.reclass", input=core_lyr, output=focal_core_rast, overwrite=True, rules="-", stdin=core_no_txt + '=' + core_no_txt) # Converting raster core to point feature run_grass_cmd("r.to.vect", flags="z", input=focal_core_rast, output=core_points, type="point") # Running r.walk to create CWD and back raster run_grass_cmd("r.walk", elevation=climate_lyr, friction=resist_lyr, output=gcwd, outdir=gback, start_points=core_points, walk_coeff=walk_coeff, slope_factor=slope_factor) # Reclassify back raster directional degree output to ArcGIS format write_grass_cmd("r.reclass", input=gback, output=gbackrc, rules="-", stdin=rc_rules) # Get spatial reference for defining ARCINFO raster projections desc_data = arcpy.Describe(cc_env.prj_core_rast) spatial_ref = desc_data.spatialReference # Get cwd path (e.g. ..\datapass\cwd\cw\cwd_3) cwd_path = lm_util.get_cwd_path(core_no) def create_arcgrid(rtype, grass_grid): """Export GRASS raster to ASCII grid and then to ARCINFO grid """ ascii_grid = os.path.join(cc_env.scratch_dir, rtype + core_no_txt + ".asc") arc_grid = cwd_path.replace("cwd_", rtype) run_grass_cmd("r.out.gdal", input=grass_grid, output=ascii_grid, format="AAIGrid") arcpy.CopyRaster_management(ascii_grid, arc_grid) arcpy.DefineProjection_management(arc_grid, spatial_ref) cc_util.arc_delete(ascii_grid) create_arcgrid("cwd_", gcwd) # Export CWD raster create_arcgrid("back_", gbackrc) # Export reclassified back raster except Exception: raise
def execute(self, parameters, messages): """The source code of the tool.""" visibility_lines = parameters[0].valueAsText id_observer_field = parameters[1].valueAsText observer_offset_field = parameters[2].valueAsText id_target_field = parameters[3].valueAsText target_offset_field = parameters[4].valueAsText target_x_field = parameters[5].valueAsText target_y_field = parameters[6].valueAsText horizons = parameters[7].valueAsText useCurvatures = parameters[8].value refCoeff = parameters[9].value workspace = fv.getPath(horizons) file_name = horizons.replace(workspace + "\\", "") arcpy.CreateFeatureclass_management( workspace, file_name, "POINT", has_z="ENABLED", spatial_reference=arcpy.Describe( visibility_lines).spatialReference) fieldsNew = [(id_observer_field, id_observer_field, "SHORT"), (id_target_field, id_target_field, "SHORT"), ("Elevation", "Elevation", "DOUBLE"), ("Hide_Tar", "Hides target point", "SHORT"), ("ViewAngle", "Viewing angle", "DOUBLE"), ("AngleDiff_Tar", "Viewing angle difference to target", "DOUBLE"), ("Dist_Observ", "Distance to observer", "DOUBLE"), ("Behind_Tar", "Behind target", "SHORT"), ("OID_LoS", "OID_LoS", "SHORT")] fieldsNames = [row[0] for row in fieldsNew] functions_arcmap.prepareDataColumns(horizons, fieldsNew) arcpy.AddMessage("\t Determination of horizons started...") insert_cursor = arcpy.da.InsertCursor(horizons, ["SHAPE@"] + fieldsNames) number_of_LoS = int( arcpy.GetCount_management(visibility_lines).getOutput(0)) arcpy.SetProgressor( "step", "Analyzing " + str(number_of_LoS) + " lines of sight...", 0, number_of_LoS, 1) with arcpy.da.SearchCursor(visibility_lines, [ "OBJECTID", "SHAPE@", id_observer_field, id_target_field, observer_offset_field, target_offset_field, target_x_field, target_y_field ]) as cursor: for row in cursor: target_x = row[6] target_y = row[7] target_offset = row[5] points = [] poi = visibility.WKTtoPoints(row[1].WKT) # get coordinates of first point for distance calculation start_point_x = float(poi[0].split(" ")[0]) start_point_y = float(poi[0].split(" ")[1]) observer_elev = float(poi[0].split(" ")[2]) + float(row[4]) target_distance = visibility.distance(target_x, target_y, start_point_x, start_point_y) sampling_distance = visibility.distance( float(poi[1].split(" ")[0]), float(poi[1].split(" ")[1]), start_point_x, start_point_y) target_index = -1 # for every point do this for i in range(0, len(poi)): parts = poi[i].split(" ") x = float(parts[0]) y = float(parts[1]) z = float(parts[2]) dist = visibility.distance(x, y, start_point_x, start_point_y) if useCurvatures: z = visibility.curvatureCorrections(z, dist, refCoeff) if i == 0: points.append([x, y, 0, observer_elev, -90]) elif math.fabs(target_distance - dist) < sampling_distance / 2: points.append([ x, y, dist, z + target_offset, visibility.angle(dist, z + target_offset - observer_elev) ]) target_index = i else: points.append([ x, y, dist, z, visibility.angle(dist, z - observer_elev) ]) results = visibility.findGlobalHorizons(points, target_index) point = arcpy.Point() for i in range(0, len(results)): hor_type = 0 point.X = results[i][0] point.Y = results[i][1] point.Z = results[i][3] ptGeometry = arcpy.PointGeometry(point) insert_cursor.insertRow([ ptGeometry, row[2], row[3], results[i][3], results[i][5], results[i][4], results[i][6], results[i][2], results[i][7], row[0] ]) arcpy.SetProgressorPosition() arcpy.ResetProgressor() arcpy.AddMessage("\t Determination of horizons sucessfuly ended.") functions_arcmap.addLayer(horizons) return
pass if arcpy.Exists(clu_buff_wgs): try: arcpy.Delete_management(clu_buff_wgs) except: pass # Re-project the AOI to WGS84 Geographic (EPSG WKID: 4326) arcpy.AddMessage("\nConverting CLU Buffer to WGS 1984...") wgs_CS = arcpy.SpatialReference(4326) arcpy.Project_management(clu_buffer, clu_buff_wgs, wgs_CS) arcpy.AddMessage("Done!\n") # Use the WGS 1984 AOI to clip/extract the DEM from the service arcpy.AddMessage("\nDownloading Data...") aoi_ext = arcpy.Describe(clu_buff_wgs).extent xMin = aoi_ext.XMin yMin = aoi_ext.YMin xMax = aoi_ext.XMax yMax = aoi_ext.YMax clip_ext = str(xMin) + " " + str(yMin) + " " + str(xMax) + " " + str(yMax) arcpy.Clip_management(source_Service, clip_ext, WGS84_DEM, "", "", "", "NO_MAINTAIN_EXTENT") arcpy.AddMessage("Done!\n") # Project the WGS 1984 DEM to the coordinate system of the input CLU layer arcpy.AddMessage("\nProjecting data to match input CLU...\n") final_CS = arcpy.Describe(source_clu).spatialReference.factoryCode cellsize = 3 arcpy.ProjectRaster_management(WGS84_DEM, final_DEM, final_CS, "BILINEAR", cellsize) arcpy.AddMessage("Done!\n")
arcpy.CreateFeatureclass_management( out_path=os.path.dirname(splitedBuffer), out_name=os.path.basename(splitedBuffer), geometry_type='POLYGON', spatial_reference=spatialReference) if perplineFC: if arcpy.Exists(perplineFC): arcpy.Delete_management(perplineFC) arcpy.CreateFeatureclass_management( out_path=os.path.dirname(perplineFC), out_name=os.path.basename(perplineFC), geometry_type='POLYLINE', spatial_reference=spatialReference) desc = arcpy.Describe(linefc) sr = desc.spatialReference arcpy.AddMessage('Spatial Reference : ' + sr.name) # Judge Coordinate System Type, only Projected Coordinate System works. if sr.type == "Projected": arcpy.AddMessage(' Starting ...') createSplittedbufferfc(splitedbuffer, perplinefc, sr) with arcpy.da.SearchCursor(linefc, ['SHAPE@', 'OBJECTID']) as linecursor: for linerow in linecursor: Position = 0 perplinelist = [] bufferPolygon = linerow[0].buffer(float(buffersize)) arcpy.CopyFeatures_management(bufferPolygon, 'in_memory\\bufferpolygon') arcpy.AddMessage(linerow[1])
in_should_replace_codes_with_values = arcpy.GetParameter(2) in_should_update_field_aliases_on_output = arcpy.GetParameter(3) in_api_has_alias_information = arcpy.GetParameter(4) in_codelists_file = arcpy.GetParameter(5) in_geo_table = arcpy.GetParameter(6) in_geo_join_field = arcpy.GetParameterAsText(7) global geom_cache geom_cache = {} global geo_fl geo_fl = 'geo_fl' arcpy.MakeFeatureLayer_management(in_geo_table, geo_fl) in_geo_fl_desc = arcpy.Describe(geo_fl) in_geo_field_info = in_geo_fl_desc.fieldInfo in_output_workspace = arcpy.GetParameterAsText(8) in_use_field_value_for_outputname = arcpy.GetParameter(9) in_sdmx_field_for_outputname = arcpy.GetParameterAsText(10) in_output_filename = arcpy.ValidateTableName(arcpy.GetParameterAsText(11)) # in_save_temp_files = arcpy.GetParameter(13) arcpy.SetProgressor('default', 'Creating working directory ...') # create working directory wd_res = create_working_directory() full_job_path = wd_res[0] now_ts = wd_res[1]
stationLyr = "stations" stationBuffer = watershedFD + os.sep + "stationsBuffer" stationElev = watershedGDB_path + os.sep + "stationElev" # --------------------------------------------------------------------- Check station interval # Exit if interval not set propertly try: float(interval) except: AddMsgAndPrint("\nStation Interval was invalid; Cannot set interpolation interval. Exiting...\n",2) sys.exit() interval = float(interval) # --------------------------------------------------------------------- Check DEM Coordinate System and Linear Units desc = arcpy.Describe(inputDEM) sr = desc.SpatialReference units = sr.LinearUnitName cellSize = desc.MeanCellWidth try: if interval < float(cellSize): AddMsgAndPrint("\nThe interval specified is less than the DEM cell size. Please re-run with a higher interval value. Exiting...\n",2) sys.exit() except: AddMsgAndPrint("\nThere may be an issue with the DEM cell size. Exiting...\n",2) sys.exit() if units == "Meter": units = "Meters" elif units == "Foot":
def featurechecks(self, input_file): arcpy = self._arcpy desc = arcpy.Describe(input_file) if desc.shapeType <> 'Polygon': print 'ERROR: Input feature is not a polygon'
#todo: import moduless import arcpy, os, string print "***\nCalculate Raster Extents\n***" #parameters folder = r"d:\tmp" fn = folder + os.path.sep + "rCatalog.csv" #processing Variables arcpy.env.workspace = folder if os.path.exists(fn): os.remove(fn) fs = open(fn, "w") fs.write("IMAGE,XMIN,YMIN,XMAX,YMAX\n") rsts = arcpy.ListRasters("*.jpg") for rst in rsts: ## newfn = string.replace(rst, ".jpg", ".tif") ## arcpy.CopyRaster_management(rst, newfn) ext = arcpy.Describe(rst).extent extDetails = folder + os.path.sep + rst + "," + str(ext.XMin) + "," + str( ext.XMax) + "," + str(ext.YMin) + "," + str(ext.YMax) + "\n" fs.write(extDetails) fs.close() print "completed"
buildTopology = True ####################################################################################################################### start = datetimePrint()[3] timeDateString = datetimePrint()[0] # Gets time and date to add to export print("Current Run: " + timeDateString) # Create a new GDB # Export names and proj if writeToMaster: exportGDBName = exportGDBPrefix + "MASTER" else: exportGDBName = exportGDBPrefix + timeDateString spatialRef = arcpy.Describe( mapAreasFCOrig ).spatialReference #Assumes mapAreaFC and mapDBs have the same projection exportGDBFullPath = exportFolder + "\\" + exportGDBName + ".gdb" if arcpy.Exists(exportGDBFullPath): print("GDB already exists") arcpy.env.workspace = exportGDBFullPath datasets = arcpy.ListDatasets() for dataset in datasets: checkAndDelete(dataset) else: print("Creating a new GDB at: " + exportGDBFullPath) arcpy.CreateFileGDB_management(out_folder_path=exportFolder, out_name=exportGDBName, out_version="CURRENT")
# Script Name: PeukerDouglas # # Created By: David Tarboton # Date: 9/29/11 # Import ArcPy site-package and os modules import arcpy import os import subprocess # Inputs inlyr = arcpy.GetParameterAsText(0) desc = arcpy.Describe(inlyr) fel=str(desc.catalogPath) arcpy.AddMessage("\nInput Elevation file: "+fel) centerweight=arcpy.GetParameterAsText(1) arcpy.AddMessage("\nCenter Smoothing Weight: "+centerweight) sideweight=arcpy.GetParameterAsText(2) arcpy.AddMessage("\nSide Smoothing Weight: "+sideweight) diagonalweight=arcpy.GetParameterAsText(3) arcpy.AddMessage("\nDiagonal Smoothing Weight: "+diagonalweight) # Input Number of Processes inputProc=arcpy.GetParameterAsText(4) arcpy.AddMessage("\nInput Number of Processes: "+inputProc) # Output ss = arcpy.GetParameterAsText(5)
def enable_copy_attachments(input_fc, output_fc): # Check if the output feature class has attachments table output_attachment_table = output_fc + '__ATTACH' if arcpy.Exists(output_attachment_table): arcpy.AddMessage("Output feature class layer already includes attachments.") exit() # Check if the input feature class has attachments table input_attachment_table = input_fc + '__ATTACH' if not arcpy.Exists(input_attachment_table): desc = arcpy.Describe(input_fc) input_attachment_table = desc.Path.split('.')[0] + '.gdb\\' + desc.Name + '__ATTACH' if not arcpy.Exists(input_attachment_table): arcpy.AddMessage("Unable to locate the attachment table for the input feature class.") else: # Enable Attachments arcpy.AddMessage("Enabling Attachments") arcpy.EnableAttachments_management(output_fc) arcpy.AddMessage("Enabled Attachments") # Copy Attachments from Input feature class to Temp feature class. arcpy.AddMessage("Copying Attachments..") outputTable = output_fc + '__ATTACH' try: # Check if the input feature class was related to the attachment tables via the ObjectID field. input_table_desc = arcpy.Describe(input_attachment_table) field_rel_objectID = [field for field in input_table_desc.fields if field.name.lower() == 'rel_objectid'] # If the input attachment table has REL_OBJECTID field then remap GUID fields between input and output attachment table. if field_rel_objectID: field_rel_globalID = [field for field in input_table_desc.fields if field.type.lower() == 'guid'] if field_rel_globalID: output_field = field_rel_globalID[0] else: arcpy.AddError("Can't copy attachments...") output_table_field_mappings = arcpy.FieldMappings() output_table_field_mappings.addTable(outputTable) input_table_field_mappings = arcpy.FieldMappings() input_table_field_mappings.addTable(input_attachment_table) output_table_globalID = [field for field in output_table_field_mappings.fields if field.type.lower() == 'guid'][0] field_index = output_table_field_mappings.findFieldMapIndex(output_table_globalID.name) fmap = output_table_field_mappings.fieldMappings[field_index] output_table_field_mappings.removeFieldMap(field_index) fmap.addInputField(input_attachment_table,output_field.name) output_table_field_mappings.addFieldMap(fmap) for input_field_map in input_table_field_mappings.fieldMappings: output_table_field_mappings.addFieldMap(input_field_map) arcpy.Append_management(input_attachment_table, outputTable, 'NO_TEST', output_table_field_mappings) else: arcpy.Append_management(input_attachment_table, outputTable) arcpy.AddMessage("Copied Attachments..") except Exception as e: arcpy.AddError(e)
gladresgdb = os.path.join(resdir, 'glad.gdb') pathcheckcreate(gladresgdb) pathcheckcreate(alosresgdb) pathcheckcreate(mod44w_resgdb) #GLAD values mean the following #0: NoData, 1: Land, 2: Permanent water, 3: Stable seasonal, 4: Water gain, 5: Water loss #6: Dry period, 7: Wet period, 8: High frequency, 10: Probable land, 11: Probable water, 12: Sparse data - exclude ######################################################################################################################## #Get list of tiles for raw GLAD tiles, mod44w (MODIS sea mask) and ALOS (DEM) print('Getting tile lists for GLAD, MODIS, and ALOS...') rawtilelist = getfilelist(glad_dir, 'class99_19.*[.]tif$') alos_tilelist = getfilelist(alos_dir, 'ALPSMLC30_[NS][0-9]{3}[WE][0-9]{3}_DSM.tif$') alos_wgsextdict = {i: arcpy.Describe(i).extent for i in alos_tilelist} mod44w_tilelist = getfilelist(mod44w_outdir, '.*[.]hdf$') #Rename all MODIS files that have points with underscores if any([ re.search('[.]', os.path.splitext(os.path.split(i)[1])[0]) for i in mod44w_tilelist ]): for modtile in mod44w_tilelist: modtile_renamed = '{}.hdf'.format( re.sub('[.]', '_', os.path.splitext(os.path.split(modtile)[1])[0])) os.rename(modtile, os.path.join(mod44w_outdir, modtile_renamed))
def topoclimate(options): try: theStart = datetime.datetime.now() # TILING options['tileNum'] = tileNum options['numTiles'] = numTiles options = set_options_and_dirs(options) copy_this_file(options) arcpy.env.scratchWorkspace = options['scratchDir'] arcpy.env.Workspace = options['scratchDir'] os.environ["TEMP"] = options['scratchDir'] os.environ["TMP"] = options['scratchDir'] # Set raster paths and export to ascii if needed. FIXME: don't really need ascii, just convenient for header code for now c2Raster = c3Raster = c4Raster = c5Raster = None options['c2Var'] = options['c3Var'] =options['c4Var'] =options['c5Var'] = None c1Raster = path.join(options['projectDir'],options['c1RasterBase']) arcpy.CalculateStatistics_management(c1Raster, "1", "1", "#") options['c1Var'] = get_raster_var(c1Raster) c2BandArray = c3BandArray = c4BandArray = c5BandArray = None if options['c2RasterBase'] is not None: c2Raster = path.join(options['projectDir'],options['c2RasterBase']) arcpy.CalculateStatistics_management(c2Raster, "1", "1", "#") options['c2Var'] = get_raster_var(c2Raster) if options['c3RasterBase'] is not None: c3Raster = path.join(options['projectDir'],options['c3RasterBase']) arcpy.CalculateStatistics_management(c3Raster, "1", "1", "#") options['c3Var'] = get_raster_var(c3Raster) if options['c4RasterBase'] is not None: c4Raster = path.join(options['projectDir'],options['c4RasterBase']) arcpy.CalculateStatistics_management(c4Raster, "1", "1", "#") options['c4Var'] = get_raster_var(c4Raster) if options['c5RasterBase'] is not None: c5Raster = path.join(options['projectDir'],options['c5RasterBase']) arcpy.CalculateStatistics_management(c5Raster, "1", "1", "#") options['c5Var'] = get_raster_var(c5Raster) descData = arcpy.Describe(c1Raster) spatialReference = descData.spatialReference options['cellSize'] = descData.MeanCellHeight header = get_header(c1Raster) descData = arcpy.Describe(c1Raster) arcpy.env.extent = descData.Extent cumDistRaster = arcpy.sa.Con((arcpy.Raster(c1Raster) > 0),0,0) if options['endBand'] == 0: approxEndBand = str(int(header['nrows']/options['blockSize'])+1) else: approxEndBand = str(options['endBand']) if options['endStripe'] == 0: approxEndStripe = str(int(header['ncols']/options['blockSize'])+1) else: approxEndStripe = str(options['endStripe']) maxNumSolvesToDo = (int(approxEndBand)-options['startBand'] + 1)*(int(approxEndStripe)-options['startStripe']+1) + 1 iter = 0 bandNum = 0 pctDone=0 pctDone2=0 partialResultsArray = None #new breakFlag = False count = 0 calcInBand = False for centerRow in range((options['blockSize']-1)/2,header['nrows'],options['blockSize']): #new count += 1 bandNum += 1 if options['startBand'] > 0 and bandNum < options['startBand']: blarg #not capable yet because of counting/partialresults continue if options['endBand'] > 0 and bandNum >= options['endBand']+1: blarg #not capable yet because of counting/partialresults breakFlag = True break print 'Starting band #',str(bandNum)+'/'+approxEndBand,' centered on row '+str(centerRow) c1BandArray, LLC = band(c1Raster,header,centerRow, options) #fixme: reinstate next line when figure out partialresults etc # if npy.max(c1BandArray) == -9999: continue c2BandArray, dummy = band(c2Raster, header, centerRow, options) c3BandArray, dummy = band(c3Raster, header, centerRow, options) c4BandArray, dummy = band(c4Raster, header, centerRow, options) c5BandArray, dummy = band(c5Raster, header, centerRow, options) #new if partialResultsArray is None: # FIXME: create partialresultsarray that is SIZE of band, but not ALIGNED with band. OR, create array that is size of REMAINDER. # LLC is same # size is # except for last band? # that's when LLC equals the LLC of the input raster #fixme: this doesn't work when using an end band! nResultsRows = options['radius']+1 # if LLC # nResultsRows > partialResultsArray = npy.zeros((nResultsRows,header['ncols']), dtype = 'float64')-9999 # partialResultsCenterRow = centerRow partialResultsLLC = LLC # print 'partialResultsArray.shape[0]' # print partialResultsArray.shape[0] subsetCenterRow = min(centerRow,options['radius']) # Check for all nodata in center band of C1 raster #Fixme: reinstate bandcenterarray check. Had to remove because continue statement screwed up partialresults etc. # if options['blockSize']>1: # bandCenterArray = c1BandArray[(subsetCenterRow-(options['blockSize']-1)/2):(subsetCenterRow+(options['blockSize']-1)/2),:] # else: # bandCenterArray = c1BandArray[subsetCenterRow,:] # if npy.max(bandCenterArray) == -9999: # del bandCenterArray # continue # del bandCenterArray # grid = npy.indices((c1BandArray.shape)) # rowArray = grid[0] # colArray = grid[1] # del grid stripeNum = 0 for centerCol in range((options['blockSize']-1)/2, header['ncols'],options['blockSize']): start_time0 = time.clock() stripeNum += 1 if options['startStripe'] > 0 and stripeNum < options['startStripe']: continue if options['endStripe'] > 0 and stripeNum >= options['endStripe']+1: break iter += 1 # print 'Band #',bandNum,'Stripe #',stripeNum c2CircleVector = c3CircleVector = c4CircleVector = c5CircleVector = None subsetCenterCol = min(centerCol,options['radius']) subsetCenterRow = min(centerRow,options['radius']) # time consuming- add smart search. # if options['blockSize']>1: # if npy.max(sourceCenterArraySum0[centerCol-(options['blockSize']-1)/2:centerCol+(options['blockSize']-1)/2+1]) <= 0: # print'No values in radius' # continue # else: # if sourceCenterArray[centerCol] <= 0: #BHM ADDED INDEX 10/12/15 # print'No sources in radius' # continue # print c1BandArray # time consuming- add smart search. if c1BandArray[subsetCenterRow, centerCol]!=-9999: #FIXME! Passing teh band array here causes memory errors on this line. Should be able to accomplish what is needed without passing. c1CircleVector= circ(c1BandArray, subsetCenterRow, centerCol, options) if c2BandArray is not None: c2CircleVector = circ(c2BandArray, subsetCenterRow, centerCol, options) # Was getting memory error calling circ with None arrays, setting to None above instead if c3BandArray is not None: c3CircleVector = circ(c3BandArray, subsetCenterRow, centerCol, options) if c4BandArray is not None: c4CircleVector = circ(c4BandArray, subsetCenterRow, centerCol, options) if c5BandArray is not None: c5CircleVector = circ(c5BandArray, subsetCenterRow, centerCol, options) # circleHeader = get_subset_header(c1CircleArray, header, options, centerRow, centerCol) # yMin = circleHeader['yllcorner'] #fixme- check. coudl be something like: max(circleHeader['yllcorner'],circleHeader['yllcorner'] + ((circleHeader['nrows'] - centerRow - options['radius'] - 1) * circleHeader['cellsize'])) # print '\nDone with prep' # start_time0 = elapsed_time(start_time0) # pctDone = report_pct_done(iter, maxNumSolvesToDo, -1) # print 'Elapsed time so far: {0}'.format(datetime.datetime.now()-theStart) # print'subs' calcInBand = True stdEucDist, options = std_euc(c1CircleVector, c2CircleVector, c3CircleVector, c4CircleVector, c5CircleVector, subsetCenterRow, subsetCenterCol, options) if options['blockSize']>1: print'error- cannot do blocks yet' exit(0) partialResultsArray[(subsetCenterRow-(options['blockSize']-1)/2):(subsetCenterRow+(options['blockSize']-1)/2)+1,(centerCol-(options['blockSize']-1)/2):(centerCol+(options['blockSize']-1)/2)+1] = stdEucDist else: # partialResultsArray[subsetCenterRow,centerCol] = stdEucDist # print 'count,centercol' # print count, centerCol partialResultsArray[count-1,centerCol] = stdEucDist # print'subcr,cc,std' # print subsetCenterRow,centerCol,stdEucDist # print 'bda' # print partialResultsArray # print 'donebda' del c1CircleVector, c2CircleVector, c3CircleVector, c4CircleVector, c5CircleVector # print 'Band Dist array:' # print partialResultsArray print 'Done with band#',str(bandNum)+'/'+approxEndBand # pctDone = report_pct_done((bandNum-options['startBand']+1)*(stripeNum-options['startStripe']+1), maxNumSolvesToDo, -1) pctDone = report_pct_done(iter+1, maxNumSolvesToDo, -1) # if calcInBand: # # partialResultsArray = #new # print 'count, target' # print count, partialResultsArray.shape[0] if count == partialResultsArray.shape[0]: print 'reset' #new #if we've filled up partialResultsArray, add it to the cumulativeraster # yMin = max(header['yllcorner'],header['yllcorner'] + ((header['nrows'] - partialResultsCenterRow - options['radius'] - 1) * header['cellsize'])) # LLC = arcpy.Point(header['xllcorner'],yMin) # print 'pra shape, llc' # print partialResultsArray, partialResultsLLC partialResultsRaster = arcpy.NumPyArrayToRaster(partialResultsArray, partialResultsLLC, header['cellsize'],header['cellsize'],-9999) # # SAVING BAND RASTER REMOVES OCCASIONAL HORIZONTAL STRIPING tempBandFile = os.path.join(options['scratchDir'], 'justBAND'+str(bandNum)+'cur_' + options['outputFileText']+'.tif') partialResultsRaster.save(tempBandFile) delete_data(tempBandFile) cumDistRaster = addData_arcpy(cumDistRaster, partialResultsRaster) del partialResultsArray partialResultsArray = None gc.collect() calcInBand=False count = 0 del partialResultsRaster options = write_temp_maps(options,cumDistRaster,bandNum) # print 'Done with band #',bandNum,', print 'Elapsed time so far: {0}'.format(datetime.datetime.now()-theStart) print 'DONE with bands' # print 'partialResultsArray, partialResultsLLC' # print partialResultsArray, partialResultsLLC # print 'partialres data' # print partialResultsArray[0:count,:] # LLC = arcpy.Point(header['xllcorner'],header['yllcorner']) if breakFlag:#there's an endband partialResultsRaster = arcpy.NumPyArrayToRaster(partialResultsArray, partialResultsLLC, header['cellsize'],header['cellsize'],-9999) else: partialResultsRaster = arcpy.NumPyArrayToRaster(partialResultsArray[0:count,:], partialResultsLLC, header['cellsize'],header['cellsize'],-9999) # # SAVING BAND RASTER REMOVES OCCASIONAL HORIZONTAL STRIPING tempBandFile = os.path.join(options['scratchDir'], 'justBAND'+str(bandNum)+'cur_' + options['outputFileText']+'.tif') partialResultsRaster.save(tempBandFile) delete_data(tempBandFile) cumDistRaster = addData_arcpy(cumDistRaster, partialResultsRaster) del partialResultsRaster # cumDistRaster.save(r'c:\md\test.tif') print 'Done with solves.' print_prof_data() write_final_maps(options,cumDistRaster) #xprint locals() return options except arcpy.ExecuteError: print_geoproc_error() except: print c1BandArray.shape print_python_error()
# -*- coding: utf-8 -*- import arcpy from arcpy.sa import * import os,time #exceptions arcpy.env.parallelProcessingFactor = 0 try: t_inicio=time.clock()# captura el tiempo de inicio del proceso arcpy.env.overwriteOutput = True in_source_data=arcpy.GetParameterAsText(0) sp=int(arcpy.Describe(in_source_data).spatialreference.factoryCode) arcpy.env.outputCoordinateSystem = arcpy.SpatialReference(sp) in_cost_raster=arcpy.GetParameterAsText(1) maximum_distance=arcpy.GetParameterAsText(2) if maximum_distance!="---": maximum_distance=int(arcpy.GetParameterAsText(2)) else: maximum_distance="" out_backlink_raster=arcpy.GetParameterAsText(3) capa_extent=arcpy.GetParameterAsText(4) capa_salida=arcpy.GetParameterAsText(5) if "....." in capa_extent: capa_extent=capa_extent.replace("....."," ") if "," not in capa_extent: if "MAXOF" in capa_extent or "MINOF"in capa_extent: arcpy.env.extent=capa_extent else: arcpy.env.extent=arcpy.Describe(capa_extent).extent
def execute(self, parameters, messages): """The source code of the tool.""" in_features = parameters[0].value start_time_field = str(parameters[1].value) end_time_field = str(parameters[2].value) ovelse_gdb = parameters[3].value track_features_name = str(parameters[4].value) time_interval = int(parameters[5].value) fc_name = "temp_" + datetime.now().strftime('%Y%m%d%H%M%S') arcpy.AddMessage( "Opprettet midlertidig feature klasse {0}\\{1}.".format( ovelse_gdb, fc_name)) arcpy.FeatureClassToFeatureClass_conversion(in_features=in_features, out_path=ovelse_gdb, out_name=fc_name) temp_features = os.path.join(str(ovelse_gdb), fc_name) has_m = "DISABLED" has_z = "DISABLED" spatial_ref = arcpy.Describe(temp_features).spatialReference arcpy.CreateFeatureclass_management(ovelse_gdb, track_features_name, "POINT", "", has_m, has_z, spatial_ref) track_features = os.path.join(str(ovelse_gdb), track_features_name) arcpy.AddMessage("Opprettet feature klasse {0}".format(track_features)) arcpy.AddField_management(track_features, "TRACKID", "LONG") arcpy.AddField_management(track_features, "DATETIME", "DATE") arcpy.AddField_management(track_features, "JNR", "TEXT") dsc = arcpy.Describe(temp_features) cursor = arcpy.SearchCursor(temp_features) track_rows = arcpy.InsertCursor(track_features) arcpy.AddMessage( "Begining populating feature klasse {0}".format(track_features)) for row in cursor: shape = row.getValue(dsc.shapeFieldName) start = row.getValue(start_time_field) end = row.getValue(end_time_field) try: jnr = row.getValue("JNR") except: jnr = "" objectid = row.getValue("OBJECTID") total_dist = shape.length if end and start: total_time = end - start duration = 0 while duration < total_time.total_seconds(): values = track_rows.newRow() values.TRACKID = objectid values.JNR = jnr values.DATETIME = start + timedelta(seconds=duration) distance = (total_dist / total_time.total_seconds()) * duration point = shape.positionAlongLine(distance) values.Shape = point track_rows.insertRow(values) duration = duration + time_interval del values else: arcpy.AddMessage( "Feature {0} har ikke TID_START eller TID_SLUTT.".format( jnr)) del cursor, row, track_rows arcpy.AddMessage("Finalizing processing features") arcpy.JoinField_management(in_data=track_features, in_field="TRACKID", join_table=temp_features, join_field="OBJECTID") if arcpy.Exists(temp_features): arcpy.AddMessage("Slette midlertidige feature klasse {0}.".format( temp_features)) arcpy.DeleteFeatures_management(temp_features) try: mxd = arcpy.mapping.MapDocument("CURRENT") dataFrame = arcpy.mapping.ListDataFrames(mxd, "*")[0] addLayer = arcpy.mapping.Layer(track_features) arcpy.mapping.AddLayer(dataFrame, addLayer) except: pass return
#S = 0.005 #T = 10000 #t = 100 #Inputs points = arcpy.GetParameterAsText(0) pumpfield = arcpy.GetParameterAsText(1) buff = float(arcpy.GetParameterAsText(2)) t = float(arcpy.GetParameterAsText(3)) T = float(arcpy.GetParameterAsText(4)) #vertical multiplier S = float(arcpy.GetParameterAsText(5)) #horizontal multiplier cellSize = float(arcpy.GetParameterAsText(6)) fileplace = arcpy.GetParameterAsText(7) outraster = arcpy.GetParameterAsText(8) outFeatureClass = outraster + "points" wellidfield = arcpy.Describe(points).OIDFieldName env.workspace = fileplace x, y = [], [] wellid = [] pump = [] for row in arcpy.da.SearchCursor(points, ["SHAPE@XY", wellidfield, pumpfield]): # Print x,y coordinates of each point feature x.append(row[0][0]) y.append(row[0][1]) wellid.append(row[1]) pump.append(row[2]) desc = arcpy.Describe(points)
def AddFeaturesToFeatureLayer(self, url, pathToFeatureClass, chunksize=0, lowerCaseFieldNames=False): """Appends local features to a hosted feature service layer. Args: url (str): The URL of the feature service layer. pathToFeatureClass (str): The path of the feature class on disk. chunksize (int): The maximum amount of features to upload at a time. Defaults to 0. lowerCaseFieldNames (bool): A boolean value indicating if field names should be converted to lowercase before uploading. Defaults to ``False``. Returns: The result from :py:func:`arcrest.agol.services.FeatureLayer.addFeatures`. Raises: ArcRestHelperError: if ``arcpy`` can't be found. Notes: If publishing to a PostgreSQL database, it is suggested to to set ``lowerCaseFieldNames`` to ``True``. """ if arcpyFound == False: raise common.ArcRestHelperError({ "function": "AddFeaturesToFeatureLayer", "line": inspect.currentframe().f_back.f_lineno, "filename": 'featureservicetools', "synerror": "ArcPy required for this function" }) fl = None try: fl = FeatureLayer(url=url, securityHandler=self._securityHandler) if chunksize > 0: fc = os.path.basename(pathToFeatureClass) inDesc = arcpy.Describe(pathToFeatureClass) oidName = arcpy.AddFieldDelimiters(pathToFeatureClass, inDesc.oidFieldName) arr = arcpy.da.FeatureClassToNumPyArray( pathToFeatureClass, (oidName)) syncSoFar = 0 messages = {'addResults': [], 'errors': []} total = len(arr) errorCount = 0 if total == '0': print("0 features in %s" % pathToFeatureClass) return "0 features in %s" % pathToFeatureClass print("%s features in layer" % (total)) arcpy.env.overwriteOutput = True if int(total) < int(chunksize): return fl.addFeatures( fc=pathToFeatureClass, lowerCaseFieldNames=lowerCaseFieldNames) else: newArr = chunklist(arr, chunksize) exprList = [ "{0} >= {1} AND {0} <= {2}".format( oidName, nArr[0][0], nArr[len(nArr) - 1][0]) for nArr in newArr ] for expr in exprList: UploadLayer = arcpy.MakeFeatureLayer_management( pathToFeatureClass, 'TEMPCOPY', expr).getOutput(0) #print(arcpy.GetCount_management(in_rows=UploadLayer).getOutput(0) + " features in the chunk") results = fl.addFeatures( fc=UploadLayer, lowerCaseFieldNames=lowerCaseFieldNames) chunkCount = arcpy.GetCount_management( in_rows=UploadLayer).getOutput(0) print(chunkCount + " features in the chunk") if chunkCount > 0: if results is not None and 'addResults' in results and results[ 'addResults'] is not None: featSucces = 0 for result in results['addResults']: if 'success' in result: if result['success'] == False: if 'error' in result: errorCount = errorCount + 1 print("\tError info: %s" % (result)) else: featSucces = featSucces + 1 syncSoFar = syncSoFar + featSucces print("%s features added in this chunk" % (featSucces)) print("%s/%s features added, %s errors" % (syncSoFar, total, errorCount)) if 'addResults' in messages: messages['addResults'] = messages[ 'addResults'] + results['addResults'] else: messages['addResults'] = results[ 'addResults'] else: messages['errors'] = result return messages else: return fl.addFeatures(fc=pathToFeatureClass, lowerCaseFieldNames=lowerCaseFieldNames) except arcpy.ExecuteError: line, filename, synerror = trace() raise common.ArcRestHelperError({ "function": "AddFeaturesToFeatureLayer", "line": line, "filename": filename, "synerror": synerror, "arcpyError": arcpy.GetMessages(2), }) except: line, filename, synerror = trace() raise common.ArcRestHelperError({ "function": "AddFeaturesToFeatureLayer", "line": line, "filename": filename, "synerror": synerror, }) finally: fl = None del fl gc.collect()