def reproject(self, new_workspace, name=None): # Project the layer from NAD 1983 to WGS 1984 if not os.path.exists(new_workspace): self.createWorkspace(new_workspace) if new_workspace==self.getWorkspace() and name==None: raise Exception('Error: Cannot overwrite. Specify a new workspace or a new layer name.') arcpy.env.overwriteOutput = True transform_method = "WGS_1984_(ITRF00)_To_NAD_1983" output_proj = "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]" print "Reprojecting {}...".format(self.getFilter()), for layer in self.scan_for_layers(): if name==None: if '.tif' in os.path.basename(layer): arcpy.ProjectRaster_management(layer, os.path.join(new_workspace, os.path.basename(layer)), output_proj, "", "", transform_method, "", "") else: arcpy.Project_management(layer, os.path.join(new_workspace, os.path.basename(layer)), output_proj, transform_method, "", "NO_PRESERVE_SHAPE", "","NO_VERTICAL") else: if '.tif' in os.path.basename(layer): arcpy.ProjectRaster_management(layer, os.path.join(new_workspace, os.path.basename(layer)), output_proj, "", "", transform_method, "", "") else: arcpy.Project_management(layer, os.path.join(new_workspace, name), output_proj, transform_method, "", "NO_PRESERVE_SHAPE", "","NO_VERTICAL") self._filter = name break self._workspace = new_workspace print "Done"
def get_zodgn(lon,lat): rectangle = zod_envelope(lon,lat) if abs(lat)<71: if abs(lon)<90: arcpy.Clip_management(zodraster,rectangle,"zodclip.tif") else: arcpy.Clip_management(zodraster1, rectangle, "zodclip.tif") lon = (lon+90) % 180 - 90 p = [tc(lon,lat),"BILINEAR", "6000"] arcpy.ProjectRaster_management("zodclip.tif", "zodgn.tif", *p) else: p = [tc(lon,lat),"BILINEAR", "6000"] arcpy.ProjectRaster_management(zodraster, "zodtemp.tif", *p) arcpy.Clip_management('zodtemp.tif', rectangle, 'zodgn.tif')
def webProducts(rast, project=True, method="POINT_REMOVE", tolerance=15, minimumArea=3000): rastName = arcpy.Describe(rast).baseName if project: arcpy.ProjectRaster_management( rastName, "WEB" + rastName, r"Coordinate Systems/Projected Coordinate Systems/World/WGS 1984 Web Mercator (Auxiliary Sphere).prj", "BILINEAR", "", "NAD_1983_to_WGS_1984_5") raster = "WEB" + rastName q = arcpy.RasterDomain_3d(raster, raster + "q", "POLYGON") qq = arcpy.Union_analysis(q, raster + "qq", "ALL", 0.1, "NO_GAPS") qqq = arcpy.Dissolve_management(qq, raster + "qqq") qqqq = arcpy.cartography.SimplifyPolygon(qqq, raster + "qqqq", method, tolerance, minimumArea, "NO_CHECK", "NO_KEEP") arcpy.Buffer_analysis(qqqq, "out_" + raster, "30 Feet", "FULL", "", "NONE") print "Products created." arcpy.Delete_management(rast) arcpy.Delete_management(raster + "q") arcpy.Delete_management(raster + "qq") arcpy.Delete_management(raster + "qqq") arcpy.Delete_management(raster + "qqqq")
def renamePRISMImagery(prism_variable, temporal_range): try: outputFolder = "H:/PRISM/4km/" + prism_variable + "/" + temporal_range + "/az/4km" # iterate through each of the year range folders dateRangeFolder = "H:/PRISM/4km/" + prism_variable + "/" + temporal_range + "/az" env.workspace = dateRangeFolder for root, dirs, files in os.walk(dateRangeFolder): for file in files: print(file) fileNameArray = file.split(".") if(fileNameArray[2] == 'tif' and len(fileNameArray) == 3): sourceFileName = dateRangeFolder + "/" + fileNameArray[0] + "." + fileNameArray[1] + ".tif" azFileName = outputFolder + "/" + str(fileNameArray[0]).replace("us", "az") + "." + fileNameArray[1] + ".tif" print(azFileName) # define the image spatial reference for the US image arcpy.ProjectRaster_management(sourceFileName,azFileName,wgs84z12_cs,"NEAREST",4307.10933863036,"","","") print("All Done!") except: print("*** Error ***") print(sys.exc_info()[0]) print(sys.exc_info()[1]) print(sys.exc_info()[2])
def clipByPoly(inPoly, inraster, outdir, topo=False): """takes a polygon and clips the inraster to its extent and places output in the outdir""" # get the raster description try: rasterDesc = arcpy.Describe(inraster) except Exception as e: print e, inraster, 'here' return None # so we can get the spatialReference of the raster rasterSpref = rasterDesc.spatialReference # and also the extent of the raster rasterExtent = rasterDesc.extent.projectAs(inPoly.spatialReference) # if it is a topo if topo: # then we use the extent without a shift because we know it is good already rawutmextent = inPoly.extent # otherwise it is for a photo or something else and we dont know that the extent is already matched up else: # use the shiftExtents function to move the clip extent to be within the raster extent rawutmextent = shiftExtents(inPoly.extent, rasterExtent) # format the extent object for clipping utmextent = ' '.join( map(str, (rawutmextent.XMin, rawutmextent.YMin, rawutmextent.XMax, rawutmextent.YMax))) # project the clip extent into the spatialReference of the raster rawextent = inPoly.projectAs(rasterSpref).extent # and reformat that as well extent = ' '.join( map(str, (rawextent.XMin, rawextent.YMin, rawextent.XMax, rawextent.YMax))) if rasterExtent.disjoint(extentToArcPolygon(rawutmextent)): print 'this is stupid' return None # create the output name # note that we are using tif so this actually works outName = os.path.join(outdir, os.path.split(inraster)[1][:-4] + '.tif') # do the initial clip to get the potion of the raster that we need arcpy.Clip_management(inraster, extent, outName, "", "", 'NONE') # if the raster spatial reference is the same as the output we can exit the function right now if rasterSpref == inPoly.spatialReference: return True # create a name for a temp file reprojectName = outName[:-4] + 'reproject' + outName[-4:] # this part can fail so we put it in a try clause # seems like most of the failures were caused by a lock, so these are not a huge issue but should still be in the try block try: # project the clipped raster into the correct UTM arcpy.ProjectRaster_management(outName, reprojectName, inPoly) # delete the original clip arcpy.Delete_management(outName) # reclip the reprojected raster arcpy.Clip_management(reprojectName, utmextent, outName, "", "", 'NONE') # and delete the reprojected unclipped raster arcpy.Delete_management(reprojectName) except Exception as e: print e, outName return True
def reshape(in_path, out_path, name, resamp_type, dem_specs, cell_size, proj, tmp_dir, roi_layers): print('Prepping ' + name + ' ...') arcpy.env.snapRaster = dem_specs.dem file_in = str(in_path) # buff = tmp_dir + '/buff_{}.tif'.format(name) buff = tmp_dir + '/buff.tif' reproj = tmp_dir + '/reproj.tif' file_out = str(out_path) arcpy.Clip_management(in_raster=file_in, out_raster=buff, in_template_dataset=roi_layers.roi_buff, clipping_geometry=True) arcpy.ProjectRaster_management(in_raster=buff, out_raster=reproj, out_coor_system=proj, resampling_type=resamp_type, cell_size=cell_size) envelope = '{} {} {} {}'.format(dem_specs.extent.XMin, dem_specs.extent.YMin, dem_specs.extent.XMax, dem_specs.extent.YMax) arcpy.Clip_management(in_raster=reproj, out_raster=file_out, rectangle=envelope, nodata_value=-9999) print('Done')
def arcReprojectData(fileList,outCRS): import arcpy import re import os from time import gmtime, strftime os.mkdir("prjdata") with open("prjdata\CRSmeta",'w') as meta: meta.write(strftime("%Y-%m-%d %H:%M:%S", gmtime())) meta.write("\n Coordinate Reference System \n") for f in fileList: # remove file extensions ext = re.match(".*(\..*)",f) print(ext) if m != None: data = f[:len(ext.group(1))] else: data = f # run the reprojection tool try: if ext=='.shp': arcpy.Project_management(data,"prjdata/"+data,outCRS) if ext!='.shp': arcpy.ProjectRaster_management(data,"prjdata/"+data,outCRS) # print messages when the tool runs successfully print(arcpy.GetMessages(0)) meta.write(arcpy.GetMessages(0)) except arcpy.ExecuteError: print(arcpy.GetMessages(2)) meta.write(arcpy.GetMessages(0)) except Exception as ex: print(ex.args[0]) meta.write(arcpy.GetMessages(0))
def ProjectRaster(workDir, inRaster,out_coor_system): # Name: Project_Raster.py # Description: Converts a raster dateset to different coordinate system. # Requirement: None # Input: working Dir, r"c:\work\path\to\dir\" # inRaster filename # output filename # in_coor_system # out_coor_system # sampling algorithm # Output: inRaster_reproject+'.tiff' # Dr. Liang Kuang, 2016/02/26 #Import system modules from os import path import arcpy from arcpy import env #proj = arcpy.SpatialReference(4326) #WGS1984 # Set environment settings env.workspace = workDir print(workDir) #env.workspace = r"R:\Projects\ESTOFS_for_Micronesia\Data\Bathymetry\ngdc_bathy\BAG\NorthernMarianas" # Set local variables #inRaster = "W00157_MB_8m_MLLW_Combined1.tif" strList = inRaster.split('.') outRaster = strList[0] + '_reproject.tiff' print(outRaster) # Reproject a Raster image to different projection #arcpy.ProjectRaster_management(inRaster,outRaster,out_coor_system,sample_alg,"#","#","#","#") arcpy.ProjectRaster_management(inRaster,outRaster,out_coor_system) print('Projection done!')
def ExtMatch(year_day, band, clipshp, tiffile, arcrast, prjfile, foldername): """This function matches all rasters to the same grid. It resamples when necessary using bilinear resampling. Returns the clipped version of the input dataset.""" arcpy.env.snapRaster = arcrast arcpy.env.extent = clipshp outprj = TMP + year_day + '_' + band + '_tightprj.tif' arcpy.ProjectRaster_management(tiffile, outprj, prjfile, 'BILINEAR', '30') out_tight = TMP + year_day + "_" + band + '_' + foldername + "_tight.tif" cliptif = arcpy.sa.ExtractByMask(outprj, clipshp) cliptif.save(out_tight) del cliptif arcpy.Delete_management(outprj) cell = arcpy.GetRasterProperties_management(out_tight, 'CELLSIZEX') cellsize = cell.getOutput(0) if cellsize <> 30: out_tight_res = TMP + year_day + "_" + band + "_tight_res.tif" arcpy.Resample_management(out_tight, out_tight_res, '30', 'BILINEAR') #Resample all datasets to same resolution arcpy.Delete_management(out_tight) arcpy.CopyRaster_management(out_tight_res, out_tight) arcpy.Delete_management(out_tight_res) return out_tight
def ExtractCover(xinfo, file='', name='', dtype='', units='', description=''): """extract land cover raster""" # then aggregate as part of reprojection info = ReadYaml(xinfo['yaml']) arcpy.env.snapraster = info['refraster'] prjrast = file + 'p' clip = os.path.join(info['outpath'], name) arcpy.ProjectRaster_management(file, prjrast, info['refraster'], 'MAJORITY', cell_size=info['cellsize']) outExtractByMask = arcpy.sa.ExtractByMask(prjrast, info['refraster']) outExtractByMask.save(clip) # create netcdf variable dev = arcpy.RasterToNumPyArray(clip) rootgrp = Dataset(info['netcdf'], 'a') lc = rootgrp.createVariable(name, dtype, ('t', 'x', 'y'), fill_value=missvals[dtype]) lc.description = description lc.units = units for i, t in enumerate(info['tcoords']): lc[i, :, :] = dev rootgrp.close() WriteYaml(info)
def execute(self, parameters, messages): '''The source code of the tool.''' in_rasterdataset = parameters[0].valueAsText in_fc = parameters[1].valueAsText in_cellsize = parameters[2].valueAsText in_field = parameters[3].valueAsText arcpy.env.workspace = in_rasterdataset ## check workspace and raster files rasterlist = arcpy.ListRasters("*") arcpy.PolygonToRaster_conversion(in_features=in_fc, value_field=in_field, out_rasterdataset="snap1", cellsize=in_cellsize) snap = "snap1" arcpy.AddMessage("Snap Raster Created") ## Project, resample, and clip rasters for raster in rasterlist: Ras = arcpy.Raster(raster) arcpy.env.snapRaster = snap projrast1 = arcpy.ProjectRaster_management(Ras, "proj1", snap, "NEAREST") resamprast1 = arcpy.Resample_management(projrast1, "resamp1", in_cellsize, "NEAREST") cliprast = arcpy.Clip_management(resamprast1, "#", raster + "_final", in_fc, "0", "ClippingGeometry") arcpy.AddMessage("Snap Raster Created") ## Delete temp files arcpy.Delete_management("resamp1") arcpy.Delete_management("proj1")
def Raster_to_Contour(): #Set up working environment arcpy.env.workspace = r"C:\GIS Automation\Florida Project\data" #Reproject Raster arcpy.ProjectRaster_management( "03meter_smoothed.tif", "03meter_smoothed_reproject.tif", "NAD 1983 StatePlane Florida East FIPS 0901 (US Feet).prj", "NEAREST") #Build pyramids for Raster #arcpy.BuildPyramids_management("f19_resample_2_reproject.tif", "-1", "NONE", "NEAREST", "NONE", "75") #Convert Raster unit from meter to feet outRas = Raster("03meter_smoothed_reproject.tif") * 3.28 outRas.save("03meter_smoothed_feet.tif") #Extract Contours arcpy.sa.Contour("03meter_smoothed_feet.tif", "contours_feet_1.shp", 1, 0) #Export to CAD input_feature = "contours_feet_1.shp" output_type = "DWG_R2013" output_file = "Contours_feet_1_crash.dwg" try: arcpy.ExportCAD_conversion(input_feature, output_type, output_file) except: print arcpy.GetMessages()
def ProjectToMatch_ras(in_Data, in_Template, out_Data, resampleType="NEAREST"): '''Check if input raster and template raster have same spatial reference. If not, reproject input to match template. Parameters: in_Data = input raster to be reprojected in_Template = dataset used to determine desired spatial reference and cell alignment out_Data = output raster resulting from resampling resampleType = type of resampling to use (NEAREST, MAJORITY, BILINEAR, or CUBIC) ''' # Compare the spatial references of input and template data (sr_In, sr_Out, reproject, transform, geoTrans) = CompareSpatialRef(in_Data, in_Template) if reproject == 0: printMsg( 'Coordinate systems for input and template data are the same. No need to reproject.' ) return in_Data else: printMsg('Reprojecting input raster to match template...') arcpy.env.snapRaster = in_Template if transform == 0: printMsg('No geographic transformation needed...') else: printMsg('Applying an appropriate geographic transformation...') arcpy.ProjectRaster_management(in_Data, out_Data, sr_Out, resampleType, "", geoTrans) return out_Data
def execute(self, parameters, messages): """The source code of your tool.""" arcpy.env.overwriteOutput = True arcpy.AddMessage("Reproject a directory of rasters into a consistent projection") for param in parameters: arcpy.AddMessage("Parameter: %s = %s" % (param.name, param.valueAsText) ) input_directory = parameters[0].valueAsText output_directory = parameters[1].valueAsText coordinate_system = parameters[2].valueAsText # Set environment settings env.workspace = input_directory rasterlist = arcpy.ListRasters("*") arcpy.AddMessage("There are " + str(len(rasterlist)) + " rasters to process.") if not os.path.exists(output_directory): os.makedirs(output_directory) for raster in rasterlist: arcpy.AddMessage("Reprojecting " + str(raster) + ".") arcpy.ProjectRaster_management(raster, os.path.join(output_directory,raster), coordinate_system,"NEAREST","#","#","#","#") return
def HSMask(year_day, clipshp, rastband, Sun_azi, Sun_elev, Asia_DEM, prj): """Clips a subset of a larger DEM, and then creates both a hillshade and a shadow mask. Returns the shadow mask, as well as a projected version of the DEM""" outDEM = Path_SRTM + year_day + "_DEM.tif" HSname = Path_SRTM + year_day + "_DEM_HS.tif" arcpy.env.snapRaster = Asia_SRTM arcpy.env.extent = clipshp SRTM_DEM_clip = arcpy.sa.ExtractByMask(Asia_DEM, clipshp) SRTM_DEM_clip.save(outDEM) prjDEM = Path_SRTM + year_day + "_DEM_prj.tif" arcpy.ProjectRaster_management(outDEM, prjDEM, prj, 'BILINEAR', '30') arcpy.Delete_management(outDEM) HS = arcpy.sa.Hillshade(prjDEM, Sun_azi, Sun_elev, "SHADOWS") #Create Hillshade image HS.save(HSname) del HS #Find shadowed areas and return a binary raster to use as a mask HS_Maskout = Path_SRTM + year_day + "_HSMask.tif" HS_Mask = arcpy.sa.Con(HSname, 1, 0, '"VALUE" < 10') HS_Mask.save(HS_Maskout) del HS_Mask arcpy.Delete_management(HSname) return HS_Maskout, prjDEM
def reprojectGeoDEM(inputDEM, outputDEM): from LUCI_SEEA.lib.external import utm log.info("DEM has geographic coordinate system. Reprojecting...") DEMSpatRef = arcpy.Describe(inputDEM).SpatialReference DEMExtent = arcpy.Describe(inputDEM).extent # Find midpoint of raster midPointX = DEMExtent.XMin + (DEMExtent.XMax - DEMExtent.XMin) / 2 midPointY = DEMExtent.YMin + (DEMExtent.YMax - DEMExtent.YMin) / 2 # Find out which UTM zone the DEM should be projected to northing, easting, zone, letter = utm.from_latlon(midPointY, midPointX) if letter >= "N": northSouth = "N" else: northSouth = "S" # Create the new projected coordinate system projSpatRef = arcpy.SpatialReference("WGS 1984 UTM Zone " + str(zone) + northSouth) # Obtain the transformation string to transform from GCS to PCS transformation = arcpy.ListTransformations(DEMSpatRef, projSpatRef, DEMExtent)[0] # Reproject DEM to Projected Coord System arcpy.ProjectRaster_management(inputDEMRaster, outputDEM, projSpatRef, geographic_transform=transformation) # Update coord system DEMSpatRef = arcpy.Describe(outputDEM).SpatialReference log.info("DEM coordinate system is now " + DEMSpatRef.Name)
def CreateUnsuitableSlopes(in_dem, outUnsuitSlope): arcpy.ProjectRaster_management(in_dem, "project", spatial_ref) x = arcpy.Describe("project").meanCellWidth y = arcpy.Describe("project").meanCellHeight cellSizeXY = "{} {}".format(x, y) #print(cellSizeXY) arcpy.Resample_management("project", "resample", cellSizeXY, "CUBIC") arcpy.Delete_management("project") # Run slope generation slope_raster = arcpy.sa.Slope("resample", "PERCENT_RISE") outInt = arcpy.sa.Int(slope_raster) arcpy.Delete_management("resample") del slope_raster # Set parameters for raster Reclassification as a boolean max_slope = outInt.maximum myRemapRange = arcpy.sa.RemapRange([[0, 10, 0], [10, int(max_slope), 1]]) ### Run reclassification outReclassRR = arcpy.sa.Reclassify(outInt, "Value", myRemapRange) # del outInt ### Query Bad Slopes #arcpy.ProjectRaster_management(outInt, "project", spatial_ref) slope_unSuit = arcpy.sa.ExtractByAttributes(outReclassRR, 'Value = 1') del outReclassRR ## Convert to Vector arcpy.RasterToPolygon_conversion(slope_unSuit, outUnsuitSlope, raster_field="Value") del slope_unSuit # Clean up geometry arcpy.RepairGeometry_management(outUnsuitSlope)
def Project_raster(rasterfile, newfile_name, coord_system=4326): sr = arcpy.SpatialReference(coord_system) new_rasterfile = rasterfile.name #if os.path.isfile(new_rasterfile): # arcpy.Delete_management(new_rasterfile) arcpy.ProjectRaster_management(rasterfile, new_rasterfile, sr) new_rasterfile1 = arcpy.Raster(new_rasterfile) return new_rasterfile1
def projectRasters(in_ws, out_coords, out_ws): env.workspace = in_ws env.overwriteOutput = True in_rasters = arcpy.ListRasters() for raster in in_rasters: print "Projecting", raster, os.path.join(out_ws, raster) arcpy.ProjectRaster_management(raster, os.path.join(out_ws, raster), out_coords)
def get_galgn(lon, lat): rectangle = gal_envelope(lon, lat) if abs(lat) < 71: if abs(lon) < 90: arcpy.Clip_management(galraster, rectangle, "galclip.tif") else: arcpy.Clip_management(galraster1, rectangle, "galclip.tif") lon = (lon + 90) % 180 - 90 p = [tc(lon, lat), "BILINEAR", "6000"] arcpy.ProjectRaster_management("galclip.tif", "galgn.tif", *p) else: p = [tc(lon, lat), "BILINEAR", "6000"] if lat >= 71: arcpy.ProjectRaster_management(galrastern, "galtemp.tif", *p) else: arcpy.ProjectRaster_management(galrasters, "galtemp.tif", *p) arcpy.Clip_management('galtemp.tif', rectangle, 'galgn.tif')
def arcReprojectBatch(wd, fileList, outCRS=None): import os, glob, re, sys, arcpy from time import gmtime, strftime arcpy.env.workspace = wd if type(fileList) is not list: print(arcReprojectBatch.__name__ + "failed, fileList must be of type list") sys.exit(arcReprojectBatch.__name__ + "failed, fileList must be of type list") if outCRS is None: ourCRS = arcpy.SpatialReference(26918) #NAD83 UTM 18N outDir = "\\prjbatch" + strftime('%Y%m%d%H%M%S', gmtime()) + "\\" os.mkdir(arcpy.env.workspace + outDir) outPath = arcpy.env.workspace + outDir print(outPath) # write metadata meta = open(outPath + "CRSmeta", 'w') meta.write(strftime("%Y-%m-%d %H:%M:%S", gmtime())) meta.write("\n Coordinate Reference System \n") for f in fileList: # remove file extensions m = re.match(".*(\..*)", f) if m == None: ext = "" data = f else: ext = m.group(1) data = f[:(len(f) - len(ext))] print(data, ext) # run the reprojection tool try: print("trying to reproject data") if ext == '.shp': out = arcpy.Project_management(wd + f, outPath + f, outCRS) if ext != '.shp': out = arcpy.ProjectRaster_management(wd + f, outPath + f, outCRS) # print messages when the tool runs successfully del out print(arcpy.GetMessages(0)) meta.write(arcpy.GetMessages(0)) except arcpy.ExecuteError: print(arcpy.GetMessages(2)) meta.write(arcpy.GetMessages(0)) except Exception as ex: print(ex.args[0]) meta.write(arcpy.GetMessages(0)) mxd = arcpy.mapping.MapDocument(r"C:\Temp\ArcGIS\Untitled.mxd") for df in arcpy.mapping.ListDataFrames(mxd): for lyr in arcpy.mapping.ListLayers(mxd, "", df): #if lyr.name.lower() == "rivers": arcpy.mapping.RemoveLayer(df, lyr)
def land_use(nlcd_layer, search_area, excluded_types, tiger_lines, census_places, crs, workspace): arcpy.CheckOutExtension("spatial") geoprocessing_log.info("Extracting NLCD raster to search area") nlcd_in_area = arcpy.sa.ExtractByMask(nlcd_layer, search_area) avoid_types = [exclude.value for exclude in excluded_types] thresholded_raster = nlcd_in_area for avoid in avoid_types: # this is inefficient, but I couldn't get it to work with a "not in" and I need something that works for n number of values thresholded_raster = arcpy.sa.Con(thresholded_raster != avoid, thresholded_raster, 0) scratch_raster = generate_gdb_filename("temp_raster", scratch=True) thresholded_raster.save( scratch_raster) # save it so we can use it for environment variables stored_environments = store_environments( ('cellSize', 'mask', 'extent', 'snapRaster') ) # cache the env vars so we can reset them at the end of this function arcpy.env.cellSize = scratch_raster arcpy.env.mask = scratch_raster arcpy.env.extent = scratch_raster arcpy.env.snapRaster = scratch_raster roads_mask = make_road_mask(tiger_lines, census_places=census_places, search_area=search_area) roads_raster = generate_gdb_filename("roads_raster") geoprocessing_log.info("Converting roads mask to raster") try: arcpy.PolygonToRaster_conversion(roads_mask, "OBJECTID", roads_raster) #arcpy.CalculateStatistics_management(roads_raster) # crashes for invalid statistics unless we run this after the conversion except: geoprocessing_log.error( "Error creating raster: {0:s} - from roads mask: {1:s}".format( roads_raster, roads_mask)) raise # Raster Calculations final_nlcd = arcpy.sa.Con(arcpy.sa.IsNull(arcpy.sa.Raster(roads_raster)), thresholded_raster, 1) intermediate_raster = generate_gdb_filename("intermediate_nlcd_mask") projected_raster = generate_gdb_filename("projected_nlcd_mask", gdb=workspace) final_nlcd.save(intermediate_raster) reset_environments(stored_environments) geoprocessing_log.info("Reprojecting final raster") arcpy.ProjectRaster_management(intermediate_raster, projected_raster, out_coor_system=crs) filtered_nlcd_poly = filter_patches.convert_and_filter_by_code( projected_raster, filter_value=0) return filtered_nlcd_poly
def _reproject_raster(self, current_ref, target_ref, file_path): """ Reproject raster """ file_name = ntpath.basename(file_path) proj_out_ras = self.dest_dir + '/PROJ_' + file_name print('Projecting..... {0} from {1} to {2}'.format( file_name, current_ref.name, target_ref.name)) arcpy.ProjectRaster_management(file_path, proj_out_ras, target_ref, '', '', '', '', current_ref) return proj_out_ras
def project (rasters, cds): outrasters = [] for raster in rasters: outraster = raster[:-4]+'_proj.tif' arcpy.ProjectRaster_management(raster, outraster, arcpy.SpatialReference(cds)) outrasters.append(outraster) return outrasters
def reproject(input_dir, output_dir, projection, meta): ''' Reproject raster band @param input_dir: landsat 8 directory after unzip @type input_dir: c{str} @param meta: metadata parsed from MTL file @type meta: dictionary @return output_dir: output directory path ''' ## ## Setting output directory id not defined ## ## if output_dir is None: ## output_dir = os.path.join(input_dir, "processed") ## if os.path.exists(output_dir): ## sys.exit(0) ## print "\nDirectory for reprojection already Exisits" ## else: ## os.mkdir(output_dir) ## print "\nCreated the output directory: " + output_dir ## else: ## if os.path.exists(output_dir): ## sys.exit(0) ## print "\nDirectory for reprojection already Exisits" ## else: ## os.mkdir(output_dir) ## print "\nCreated the output directory: " + output_dir ap.env.workspace = input_dir rasters = ap.ListRasters('*.TIF') ms_bands = [band for band in rasters if (band_nmbr(band) != None)] bqa_band = [band for band in rasters if (band_nmbr(band) == None)][0] try: checkout_Ext("Spatial") print "\nReprojecting and Cleaning landsat bands." ap.AddMessage("\nReprojecting and Cleaning landsat bands.") for band in ms_bands: print "\nReclassifying NoData for band " + band ap.AddMessage("\nReclassifying NoData for band " + band) outCon = ap.sa.Con(ap.sa.Raster(bqa_band) != 1, ap.sa.Raster(band)) out_band = os.path.join(output_dir, band) print "Reprojecting band" ap.AddMessage("Reprojecting band") ap.ProjectRaster_management(outCon, out_band, projection) except SpatialRefProjError: ap.AddError( "Spatial Data must use a projected coordinate system to run") except LicenseError: ap.AddError("Spatial Analyst license is unavailable") finally: checkin_Ext("Spatial")
def mosaic(): global nhdsubregion # Select the right HUC4 from WBD_HU4 and make it it's own layer. arcpy.MakeFeatureLayer_management("WBD_HU4", "HU4") field = "HUC_4" where = '"' + field + '" = ' + "'" + str(nhdsubregion) + "'" arcpy.SelectLayerByAttribute_management("HU4", "NEW_SELECTION", where) arcpy.CopyFeatures_management("HU4", "Subregion") # Apply a 5000 meter buffer around subregion arcpy.Buffer_analysis("Subregion", "Subregion_5000m_buffer", "5000 meters") arcpy.AddMessage("Buffered subregion.") # Naming conventions for mosaic output file subregion_number = os.path.basename(nhd) nhdsubregion = subregion_number[4:8] # Walk through the folder with NEDs to make a list of rasters mosaicrasters = [] for dirpath, dirnames, filenames in arcpy.da.Walk( nedfolder, datatype="RasterDataset"): for filename in filenames: name = os.path.join(dirpath, filename) mosaicrasters.append(name) arcpy.AddMessage("Found NED ArcGrids.") # Mosaic, clip and then project to USGS Albers arcpy.MosaicToNewRaster_management(mosaicrasters, outfolder, "mosaicNAD.tif", nad83, "32_BIT_FLOAT", "", "1", "LAST") arcpy.Clip_management( outfolder + "\\" + "mosaicNAD.tif", '', outfolder + "\\" + "tempNED13_" + nhdsubregion + ".tif", "Subregion_5000m_buffer", "0", "ClippingGeometry") tempned13 = os.path.join(outfolder, "tempNED13_" + nhdsubregion + ".tif") arcpy.ProjectRaster_management( tempned13, os.path.join(mosaicfolder, "NED13_" + nhdsubregion + ".tif"), albers, "BILINEAR", "10", "", "", nad83) arcpy.AddMessage("Mosaiced, clipped and projected NED tiles.") # Variables for intermediate data MosaicNAD = os.path.join(outfolder, "mosaicNAD.tif") MosaicClip = outfolder + "\\" + "tempNED13_" + nhdsubregion + ".tif" subregion_ned = outfolder + "\\" + "mosaic" + nhdsubregion + "\\" + "NED13_" + nhdsubregion + ".tif" global subregion_ned # Clean up arcpy.Delete_management(MosaicNAD) arcpy.Delete_management(MosaicClip) arcpy.Delete_management("Subregion") arcpy.Delete_management("Subregion_5000m_buffer") arcpy.AddMessage( "Cleaned up intermediate data from mosaic tool. Mosaic done.") return
def DTE(tiffile): ## Retrieve country ISO: iso = tiffile.split("/")[3].split("\\")[0] print("Working on {0}".format(iso)) ## Set the output path: outpath = tiffile.split(os.path.basename(tiffile))[0] print("\tProjecting Data...") ## Project the dataset ## ## Retrieve projection from dictionary: intermediate_prj = prj_dict[iso] ## Set the ouput data name: outpath = ensure_dir(tiffile.split(".tif")[0] + "tmp/") output = outpath + "_projected.tif" ## Project the dataset: data_desc = arcpy.Describe(tiffile) input_prj = data_desc.SpatialReference.exportToString() arcpy.ProjectRaster_management(tiffile, output, intermediate_prj, "NEAREST", "100", "#", "#", input_prj) ## Retrieve the projected dataset: prjtif = output print("\tPolygonizing...") ## Calculate the DTE ## ## Raster to Polygon: arcpy.RasterToPolygon_conversion(prjtif, "D:/tmp/" + iso + "_polyras.shp", "NO_SIMPLIFY", "VALUE") polyras = "D:/tmp/" + iso + "_polyras.shp" ## Convert the polygon to a feature layer: polyfeat = arcpy.MakeFeatureLayer_management(polyras, "polyras") print("\tLinizing...") ## Polygon to Line: arcpy.PolygonToLine_management(polyfeat, "D:/tmp/" + iso + "_polyline.shp", "IGNORE_NEIGHBORS") polyline = "D:/tmp/" + iso + "_polyline.shp" print("\tCalculating Distance to Line...") ## Distance to Line: output = "D:/tmp/" + iso + "dst.tif" dstras = arcpy.sa.EucDistance(polyline, cell_size=100) dstras.save(output) ## Convert the internal numbers to negative using rastermath: print("\tCalculating negative values...") outpath = ensure_dir(tiffile.split(".tif")[0] + "Output/") output = outpath + "_projected_DTE.tif" urb = arcpy.Raster(tiffile) dteras = arcpy.sa.Con(urb == 1, -1, 0) * dstras + arcpy.sa.Con( urb == 0, 1, 0) * dstras dteras.save(output)
def proj_ras(self): """Project each raster as specified""" for source_path in self.get_dir_paths(): for file in os.listdir(source_path): if file.startswith("africa_") & file.endswith(".tif"): # Check if TIF file file_path = os.path.join(source_path, file).replace("\\","/") out_ras = "E:/Omusati_covariates/ndvi/processed_data/" + file print("PROJECTING ...... " + file) arcpy.ProjectRaster_management(file_path, out_ras, "PROJCS['UTM_Zone_33S',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',10000000.0],PARAMETER['Central_Meridian',15.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]", "NEAREST", "250 250", "", "", "PROJCS['Sphere_Sinusoidal',GEOGCS['GCS_Sphere',DATUM['D_Sphere',SPHEROID['Sphere',6370997.0,0.0]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Sinusoidal'],PARAMETER['false_easting',0.0],PARAMETER['false_northing',0.0],PARAMETER['central_meridian',30.0],UNIT['Meter',1.0]]") print("ALL RASTERS PROJECTED SUCCESSFULLY!!!!!")
def project_batch(): env.workspace = raster_path rafters = arcpy.ListRasters("*", "tif") for raster in rafters: out = "\\" + new_path_name + "\\" + "Pr_" + raster[:] arcpy.ProjectRaster_management(raster, out, out_coor_system, rs_type, c_size, "#", "#", "#") arcpy.AddMessage("Step2:Pr_" + raster[:] + "has done.") arcpy.SetProgressorPosition() arcpy.AddMessage("Step2:Completed")
def project_raster(path, null_raster): #in_Raster=os.path.join(Path,Copied_Raster_Name) #Read_Project_Raster=arcpy.Raster(in_Raster) out_projected_raster = os.path.join( path, projected_raster_name) arcpy.ProjectRaster_management( null_raster, out_projected_raster, self.projection, "BILINEAR", "#", "#", "#", "#") return out_projected_raster