# Created: 06/10/2017 #------------------------------------------------------------------------------- import arcpy from arcpy import env env.workspace = r'D:/Geoprocessing/HW/HW7' env.OverwriteOutput = True inFile = "BaileysRegions.shp" #Project file projFile = "baileys_albers.shp" if arcpy.Exists(projFile): arcpy.Delete_management(projFile) print 'File exists and is being deleted' arcpy.Project_management( inFile, projFile, "PROJCS['NAD_1983_Texas_Centric_Mapping_System_Albers',GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Albers'],PARAMETER['False_Easting',1500000.0],PARAMETER['False_Northing',6000000.0],PARAMETER['Central_Meridian',-100.0],PARAMETER['Standard_Parallel_1',27.5],PARAMETER['Standard_Parallel_2',35.0],PARAMETER['Latitude_Of_Origin',18.0],UNIT['Meter',1.0]]", "", "GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", "NO_PRESERVE_SHAPE", "", "NO_VERTICAL") print 'File projected' #Select by attribute selectFile = "great_plains.shp" if arcpy.Exists(selectFile): arcpy.Delete_management(selectFile) print 'File exists and is being deleted' arcpy.Select_analysis( projFile, selectFile, "\"PROVINCE\" = 'Great Plains Steppe and Shrub Province'") print 'Attributes selected' #Buffer
wbsr.create() webMercator = wbsr #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_towerrangefanlos") arcpy.CopyFeatures_management(tower, copyInFeatures) deleteme.append(copyInFeatures) prjInFeature = os.path.join(scratch, "prjInFeature_towerrangefanlos") srInputPoints = arcpy.Describe(copyInFeatures).spatialReference if DEBUG == True: arcpy.AddMessage("Projecting input points to Web Mercator ...") arcpy.Project_management(copyInFeatures, prjInFeature, webMercator) deleteme.append(prjInFeature) tempFans = os.path.join(env.scratchWorkspace, "tempFans_towerrangefanlos") ######################################################################### # Create Range Fans ######################################################################### # 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))
#export outpath = "C:\Users\dmehri\Documents\DATA\ArcGIS\Spatial_Join\output" arcpy.FeatureClassToFeatureClass_conversion("InspectionList_points", outpath, "InspectionListPoints.shp") #Project the points #set input feature as savled shape file input_features = "C:\Users\dmehri\Documents\DATA\ArcGIS\Spatial_Join\output\InspectionListPoints.shp" #ouput data output_feature_class = "C:\Users\dmehri\Documents\DATA\ArcGIS\Spatial_Join\output\InspectionListProjectedPoints.shp" # create a spatial reference object for the output coordinate system out_coordinate_system = arcpy.SpatialReference( 'NAD 1983 (2011) StatePlane New York Long Isl FIPS 3104 (US Feet)') #run the projected points tool arcpy.Project_management(input_features, output_feature_class, out_coordinate_system) #Now the projected points are exported, delete layers not needed anymore #arcpy.Delete_management("InspectionListProjectedPoints") #arcpy.Delete_management("InspectionList_points") #arcpy.Delete_management("InspectionList") #arcpy.Delete_management("InspectionListPoints") print "DONE WITH PROJECTED POINTS" """ the below code creates a spatial join with community districts and projected points shape files, then applies graduated colors to the new spatial join layer """ print "Running Spatial join"
driver='ESRI Shapefile', schema=myschema) as output: output.write({ 'geometry': geometry.mapping(concave_hull), 'properties': { 'id': 107187 } }) output.close proj = arcpy.projection(3686) arcpy.Define_Projection_management(tempShp, proj) outShp = arcpy.CreateLayer(inWs + "\\" + dgnName + "Outline.shp") reProj = arcpy.projection(3857) arcpy.Project_management(tempShp, outShp, reProj) arcpy.Delete_management(tempShp) #get the input layer ## inShp = inWs + "\\" + dgnName + "Outline.shp" ## driver = ogr.GetDriverByName('ESRI Shapefile') ## ## polyShp = driver.Open(outShp) ## polyLyr = polyShp.GetLayer() ## ## #create the output layer ## outShp2 = inWs + "\\" + dgnName + "Outline2.shp" ## outDataSet = driver.CreateDataSource(outShp2) ## outLayer = outDataSet.CreateLayer("basemap_4326", geom_type=ogr.wkbMultiPolygon) ## outLayerDefn = outLayer.GetLayerDefn() ## ## inCS = osr.SpatialReference()
kab = str('"') + line[7] + str('"') kec = str('"') + line[8] + str('"') pro = str('"') + line[6] + str('"') #print print shp print output #Change workspace arcpy.env.workspace = str(os.path.join(tools_folder, gdb, pmn)) arcpy.env.overwriteOutput = True print arcpy.env.workspace # Process: Project (moving) print 'Moving Feature ' + output + ' to Database' #project arcpy.Project_management( shp, output, "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", "", "", "NO_PRESERVE_SHAPE", "", "NO_VERTICAL") # Process: Add Field print 'Creating Fields for Feature ' + output # objID arcpy.AddField_management(output, "objID", "SHORT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(output, "objID", "[OBJECTID]", "VB", "") # objType arcpy.AddField_management(output, "objType", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") # objYear
arcpy.env.overwriteOutput = True lista = fnmatch.filter(os.listdir(path), "*.tif") namesLista = [x[:3] for x in lista] for x in range(len(namesLista)): raster = arcpy.Raster(os.path.join(path, lista[x])) spr = raster.spatialReference if spr.name == u'WGS_1984_UTM_Zone_17S': spn = arcpy.SpatialReference(32717) elif spr.name == u'WGS_1984_UTM_Zone_18S': spn = arcpy.SpatialReference(32718) elif spr.name == u'WGS_1984_UTM_Zone_19S': spn = arcpy.SpatialReference(32719) else: spn = arcpy.SpatialReference(4326) areaHoja = arcpy.MakeFeatureLayer_management( shp, "in_memory\ghp", "COD_100 = '{}'".format(namesLista[x])) areaHojaN = arcpy.Project_management(areaHoja, os.path.join(path, "temp.shp"), spn) pathRaster = '{}'.format(''.join([namesLista[x], ".tif"])) pathRaster2 = os.path.join(path, 'RASTER', pathRaster) dsc = arcpy.Describe(areaHojaN) Rectangle = dsc.Extent.__str__().replace('NaN', '') arcpy.Clip_management(raster, Rectangle, pathRaster2)
def execute(self, parameters, messages): """The source code of the tool.""" # local variables and env arcpy.env.workspace = "E:/gina/poker/pip" adnr_lo_shp = "E:/gina/poker/shp/wip/land_ownership_data/adnr_gls_dls_merge_20170823_v1.shp" pfrr_popn_places = "E:/gina/poker/shp/wip/popn_places_data/pokerflat_popn_places_gcs_wgs84_to_akalbers_2.shp" pipTable = "E:/gina/poker/dbf/predicted_impact_xy.dbf" pip_point_shp = "E:/gina/poker/pip/pip_point.shp" pip_point_3338 = "E:/gina/poker/pip/pip_point_3338.shp" pip_buffer_shp = "E:/gina/poker/pip/pip_buffer.shp" pip_lo_in_buffer_shp = "E:/gina/poker/pip/pip_lo_in_buffer.shp" pip_lo_in_buf_sum_dbf = "E:/gina/poker/pip/pip_lo_in_buf_sum.dbf" pip_lo_in_buf_sum_csv = "E:/gina/poker/pip/pip_lo_in_buf_sum.csv" pip_popn_places_in_buffer_shp = "E:/gina/poker/pip/pip_popn_places_in_buffer.shp" x = parameters[0].valueAsText y = parameters[1].valueAsText r = parameters[2].valueAsText + " NauticalMiles" pipLayer = "pipLayer" srs = arcpy.SpatialReference("Alaska Albers Equal Area Conic") intersect_fc1 = [adnr_lo_shp, pip_buffer_shp] intersect_fc2 = [pfrr_popn_places, pip_buffer_shp] mxd = arcpy.mapping.MapDocument("current") dataframe = arcpy.mapping.ListDataFrames(mxd)[0] sourceLoSymbologyLayer = arcpy.mapping.Layer( "E:/gina/poker/lyr/lo2.lyr") sourcePipSymbologyLayer = arcpy.mapping.Layer( "E:/gina/poker/lyr/pip.lyr") # Process: Calculate Lon Field arcpy.CalculateField_management(pipTable, "Lon", x, "PYTHON", "") # Process: Calculate Lat Field arcpy.CalculateField_management(pipTable, "Lat", y, "PYTHON", "") # Process: Make XY Event Layer arcpy.MakeXYEventLayer_management( pipTable, "Lon", "Lat", pipLayer, "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]];-400 -400 1000000000;-100000 10000;-100000 10000;8.98315284119522E-09;0.001;0.001;IsHighPrecision", "") # Process: Copy Features arcpy.CopyFeatures_management(pipLayer, pip_point_shp, "", "0", "0", "0") # Process: Project pip point arcpy.Project_management(pip_point_shp, pip_point_3338, srs) # Process: Buffer pip point arcpy.Buffer_analysis(pip_point_3338, pip_buffer_shp, r, "FULL", "ROUND", "NONE", "", "PLANAR") # Process: Intersect pip buffer with land ownership arcpy.Intersect_analysis(intersect_fc1, pip_lo_in_buffer_shp, "ALL", "", "INPUT") # Process: Intersect pip buffer with popn places arcpy.Intersect_analysis(intersect_fc2, pip_popn_places_in_buffer_shp, "ALL", "", "INPUT") # Process: Make feature layers and add to the map ## pip feature class list fclist = arcpy.ListFeatureClasses() ## pip layer arcpy.MakeFeatureLayer_management(pip_point_3338, "Predicted Impact Point") ## land ownership layer arcpy.MakeFeatureLayer_management( pip_lo_in_buffer_shp, "Land Ownership within 3sigma of Predicted Impact Point") ## populated places layer popn_places_records = int( arcpy.GetCount_management(pip_popn_places_in_buffer_shp).getOutput( 0)) if popn_places_records > 0: arcpy.MakeFeatureLayer_management( pip_popn_places_in_buffer_shp, "Populated Places within 3sigma of Predicted Impact Point") addPipPopnPlacesLayer = arcpy.mapping.Layer( "Populated Places within 3sigma of Predicted Impact Point") arcpy.mapping.AddLayer(dataframe, addPipPopnPlacesLayer) addPipPointLayer = arcpy.mapping.Layer("Predicted Impact Point") arcpy.mapping.AddLayer(dataframe, addPipPointLayer) add3sigmaLoLayer = arcpy.mapping.Layer( "Land Ownership within 3sigma of Predicted Impact Point") arcpy.mapping.AddLayer(dataframe, add3sigmaLoLayer) # Add and calc Acres field for intersected Land Ownership arcpy.AddField_management(pip_lo_in_buffer_shp, "Acres", "DOUBLE") arcpy.CalculateField_management(pip_lo_in_buffer_shp, "Acres", "!shape.area@acres!", "PYTHON_9.3", "") # Summarize intersected Land Ownership by Owner and total Acres arcpy.Statistics_analysis(pip_lo_in_buffer_shp, pip_lo_in_buf_sum_dbf, "Acres SUM", "OWNER") # arcpy.MakeTableView_management(pip_lo_in_buf_sum_dbf) add3sigmaLoSumTbl = arcpy.mapping.TableView(pip_lo_in_buf_sum_dbf) arcpy.mapping.AddTableView(dataframe, add3sigmaLoSumTbl) # Symbolize and Refresh lo_layer = arcpy.mapping.ListLayers( mxd, "*Land Ownership within 3sigma of Predicted Impact Point*", dataframe)[0] arcpy.mapping.UpdateLayer(dataframe, lo_layer, sourceLoSymbologyLayer, True) lo_layer.symbology.addAllValues() pip_layer = arcpy.mapping.ListLayers(mxd, "*Predicted Impact Point*", dataframe)[0] arcpy.mapping.UpdateLayer(dataframe, pip_layer, sourcePipSymbologyLayer, True) arcpy.RefreshTOC() arcpy.RefreshActiveView() return
for fC in fCList: # For files in the feature classes list.. desc = arcpy.Describe( fC) # ..describe them for multiple purposes for later use spatialRef = desc.spatialReference # Describe the spatial reference system of the files if spatialRef.Name == 'Unknown': # If spatial reference system is unknown.. continue # ..go to Line 43 print "\n" + fC, ( "has an 'Unknown' spatial reference\n" ) # Display list of names of feature classes with no spatial reference system else: definedfC = fC + '_UTM_1983' # Name of output file prjFile = 'Coordinate Systems/Projected Coordinate Systems/UTM/NAD 1983/NAD 1983 UTM Zone 11N.prj' # Default path to .prj file in ArcMap arcpy.Project_management( fC, definedfC, prjFile) # Define projection function from ArcPy for fC in fCList: # For files in the feature classes list.. if spatialRef.Name == 'Unknown': # ..if spatial reference system is unknown.. print "\n" + fC, ("has an 'Unknown' spatial reference\n" ) # ..display those files else: Unknown = [ fC for fC in fCList if arcpy.Describe(fC).spatialReference.Name == 'Unknown' ] # List of files with unknown spatial reference Known = len(fCList) - len( Unknown ) # Determine the number of files with known spatial reference system
def getAOIarea(): sr = arcpy.Describe( aoiBasin ).SpatialReference # Determine aoiBasin spatial reference system srname = sr.name srtype = sr.type srunitname = sr.linearUnitName # Units arcpy.AddMessage("\nAOI basin spatial reference: " + srname + "\nUnit type: " + srunitname + "\nSpatial reference type: " + srtype) aoiArea = 0.0 rows = arcpy.SearchCursor(aoiBasin) for row in rows: feat = row.getValue("Shape") aoiArea += feat.area if srtype == 'Geographic': # Must have a surface projection. If one doesn't exist it projects a temporary file and uses that. arcpy.AddMessage( "\n***The basin shapefile's spatial reference 'Geographic' is not supported. Projecting temporary shapefile for AOI.***" ) arcpy.Project_management( aoiBasin, env.scratchGDB + "\\TempBasin", 102039 ) #Projects AOI Basin (102039 = USA_Contiguous_Albers_Equal_Area_Conic_USGS_version) TempBasin = env.scratchGDB + "\\TempBasin" # Path to temporary basin created in scratch geodatabase sr = arcpy.Describe( TempBasin ).SpatialReference # Determine Spatial Reference of temporary basin aoiArea = 0.0 rows = arcpy.SearchCursor( TempBasin) # Assign area size in square meters for row in rows: feat = row.getValue("Shape") aoiArea += feat.area aoiArea = aoiArea * 0.000000386102 # Converts square meters to square miles elif srtype == 'Projected': # If a projection exists, it re-projects a temporary file and uses that for data consistency. arcpy.AddMessage( "\n***The basin shapefile's spatial reference will be reprojected to USA_Contiguous_Albers_Equal_Area_Conic_USGS_version for data consistency. Projecting temporary shapefile for AOI.***" ) arcpy.Project_management( aoiBasin, env.scratchGDB + "\\TempBasin", 102039 ) #Projects AOI Basin (102039 = USA_Contiguous_Albers_Equal_Area_Conic_USGS_version) TempBasin = env.scratchGDB + "\\TempBasin" # Path to temporary basin created in scratch geodatabase sr = arcpy.Describe( TempBasin ).SpatialReference # Determine Spatial Reference of temporary basin aoiArea = 0.0 rows = arcpy.SearchCursor( TempBasin) # Assign area size in square meters for row in rows: feat = row.getValue("Shape") aoiArea += feat.area aoiArea = aoiArea * 0.000000386102 # Converts square meters to square miles aoiArea = round(aoiArea, 3) arcpy.AddMessage("\nArea of interest: " + str(aoiArea) + " square miles.") if arcpy.GetParameter(5) == False: aoiArea = arcpy.GetParameter(6) # Enable a constant area size aoiArea = round(aoiArea, 1) arcpy.AddMessage("\n***Area used for PMP analysis: " + str(aoiArea) + " sqmi***") return aoiArea
# Process: Get the InputDataset File Name InputFileName = os.path.basename(InputDataset).rstrip( os.path.splitext(InputDataset)[1]) OutputProject = DataPath + "\\Scratch.gdb\\" + InputFileName + "_Project" OutputShapefile = DataPath + os.path.sep + "Shapefiles" + os.path.sep OutputZipFiles = DataPath + os.path.sep + "ZipFiles" + os.path.sep OutputFCLocation = DataPath + "\\NDUpdate20140930.gdb\\Provider_Coverage\\" OutTable = DataPath + "\\NDUpdate20140930.gdb\\" + "tbl_CheckGeo_" + InputFileName # Create a copy of the input FeatureClass arcpy.FeatureClassToFeatureClass_conversion(InputDataset, OutputFCLocation, InputFileName, "") # Process: Project the Input Dataset to WGS84 arcpy.Project_management(InputDataset, OutputProject, outCS, "WGS_1984_(ITRF00)_To_NAD_1983") #Check Geometry arcpy.CheckGeometry_management(OutputProject, OutTable) #Repair Geometry arcpy.RepairGeometry_management(OutputProject) values = [row[0] for row in arcpy.da.SearchCursor(OutputProject, (fieldName))] uniqueValues = set(values) uniqueValues2 = list(uniqueValues) x = 0 for value in uniqueValues2: #Create the query
str_bef = "PROJCS['Equirectangular_Moon',GEOGCS['GCS_Moon',DATUM['D_Moon',SPHEROID['Moon_localRadius',1737400.0,0.0]],PRIMEM['Reference_Meridian',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Equidistant_Cylindrical'],PARAMETER['false_easting',0.0],PARAMETER['false_northing',0.0]," str_cent_med = "PARAMETER['central_meridian'," + str( cent_med) + "]," str_parall = "PARAMETER['standard_parallel_1'," + str( std_parall) + "]," str_after = "UNIT['Meter',1.0]]" # the whole string is spatialReference_new = str_bef + str_cent_med + str_parall + str_after # projection arcpy.Project_management(in_dataset="CENTER_TMP", out_dataset="CENTER_PROJ", out_coor_system=spatialReference_new, transform_method="", in_coor_system=spatialReference, preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") # buffer creation arcpy.Buffer_analysis("CENTER_PROJ", out, bufferField, sideType, endType, dissolveType) # run feature to envelope tool arcpy.FeatureEnvelopeToPolygon_management( pathdab + "miniarea_TMP", pathdab + "miniarea_square", "SINGLEPART") #reproject in normal arcpy.Project_management(
arcpy.MakeFeatureLayer_management (_selected_watersheds, layerName) # Join the feature layer to a table arcpy.AddJoin_management(in_layer_or_view=layerName, in_field=infield, join_table=_zonalStatsMean, join_field=joinfield, join_type="KEEP_COMMON" ) # Copy the layer to a new permanent feature class arcpy.CopyFeatures_management(layerName, _watershed_with_mean) # Local variables: watershed_with_mean_Project = os.path.join(output_loc,"X_watershed_with_mean_Project") # Process: Project arcpy.Project_management(_watershed_with_mean, watershed_with_mean_Project, "PROJCS['WGS_1984_UTM_Zone_43N',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',0.0],PARAMETER['Central_Meridian',75.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]", "", "GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", "NO_PRESERVE_SHAPE", "", "NO_VERTICAL") # Step 5 # select intersecting watershed to contributing area # finding contributing area (actual) a_area = [] with arcpy.da.SearchCursor(watershed_with_mean_Project, ['Shape_Area']) as cursor: for row in cursor: a_area.append(row[0]) print('area is: {}'.format(sum(a_area))) list_excel.append(sum(a_area))
arcpy.CreateFolder_management(working_directory, "outputFiles") # Name the map and dataframe for removing layers # ---------------------------------------------- mxd = arcpy.mapping.MapDocument("CURRENT") df = arcpy.mapping.ListDataFrames(mxd)[0] # =================== # Reproject Flowlines # =================== # Define the projection to use (that of the wetlands) projection_definition = wetlandsFolder + "/" + states[ 0] + "_wetlands.gdb/" + states[0] + "_Wetlands" # Reproject the flowlines arcpy.Project_management(flowlinesFile, working_db + "/flowlines_prj", projection_definition) # =================== # Create Range Raster # =================== # Generates a blank raster of the entire range. This raster will serve as the template to which the state rasters will be mosaicked. spatial_ref = arcpy.Describe(wetlandsFolder + "/" + states[1] + "_wetlands.gdb/" + states[1] + "_Wetlands").spatialReference # Project the states file to match the wetlands arcpy.Project_management(statesFile, working_db + "/statesFilePrj", spatial_ref) arcpy.Sort_management(working_db + "/statesFilePrj",
raster_field="Value", simplify="NO_SIMPLIFY") print " Dissolving features into contiguous forest features" arcpy.Dissolve_management( legal_loss_year_PRODES_noFire_neighbor_shp, legal_loss_year_PRODES_noFire_neighbor_shp_dissolve, dissolve_field=["gridcode"], multi_part="MULTI_PART") print " End time is", str(datetime.datetime.now()) print " Reprojecting {} loss area to World Eckert IV".format(year) print " Start time is", str(datetime.datetime.now()) out_coordinate_system = "PROJCS['World_Eckert_IV',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Eckert_IV'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],UNIT['Meter',1.0]]" arcpy.Project_management( legal_loss_year_PRODES_noFire_neighbor_shp_dissolve, legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj, out_coor_system=out_coordinate_system, transform_method="") print " End time is", str(datetime.datetime.now()) print " Calculating feature areas" print " Start time is", str(datetime.datetime.now()) arcpy.CalculateAreas_stats( legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj, legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj_areas) print " End time is", str(datetime.datetime.now()) # Keeps only the features that are larger than 6.25 ha (Brazil exclusion criteria 4) print " Selecting features larger than 6.25 ha" print " Start time is", str(datetime.datetime.now()) where = "F_AREA > 62500"
NED19smooth = os.path.join(rootdir, 'results/ned19_smooth') NED13smooth = os.path.join(rootdir, 'results/ned13_smooth') Seattleroads = os.path.join( rootdir, 'data/CitySeattle_20180601/Seattle_Streets/Seattle_Streets.shp') UTM10 = arcpy.SpatialReference(26910) sroadsras = os.path.join(PSgdb, 'Seattle_roadras') srangetab19 = os.path.join(PSgdb, 'Seattle_elv19range') srangetab13 = os.path.join(PSgdb, 'Seattle_elv13range') Seattleroadsproj = os.path.join(PSgdb, 'Seattle_roadproj') ######################################################################################################################### #ANALYSIS #Compare to Seattle roads slope values. Apply same method to Seattle road dataset roadproj = arcpy.Project_management(Seattleroads, Seattleroadsproj, UTM10) #Densify roads arcpy.CopyFeatures_management(Seattleroadsproj, Seattleroadsproj + 'dens10m') arcpy.Densify_edit(Seattleroadsproj + 'dens10m', densification_method='DISTANCE', distance='10', max_deviation='1.5') #Split at vertices arcpy.SplitLine_management(Seattleroadsproj + 'dens10m', Seattleroadsproj + 'split10') #Compute statistics arcpy.PolylineToRaster_conversion(Seattleroadsproj + 'split10', 'OBJECTID_1', sroadsras,
def do_analysis(inFeatureClass, outFeatureClass, lengthNum, lengthField, blockWidthValue, referenceFeatureClass): """This function will create blocks in one location based on the incoming reference centroid for the purpose of being used for data driven design applications in CityEngine.""" # try: # Delete Existing Output arcpy.env.overwriteOutput = True if arcpy.Exists(outFeatureClass): arc_print("Deleting existing output feature.", True) arcpy.Delete_management(outFeatureClass) workspace = os.path.dirname(outFeatureClass) tempOutName = arcpy.ValidateTableName("TempBlockFC_1", workspace) tempOutFeature = os.path.join(workspace, tempOutName) # Add New Fields arc_print("Adding new fields for old object IDs and geometry name.", True) OldObjectIDName = "UniqueFeatID" GeometryName = "CEStreetName" AddNewField(inFeatureClass, OldObjectIDName, "LONG") AddNewField(inFeatureClass, GeometryName, "TEXT") # Create feature class to get outputFC arc_print("Making a new output feature class using the input as a template", True) OutPut = arcpy.CreateFeatureclass_management(workspace, tempOutName, "POLYLINE", template=inFeatureClass, spatial_reference=inFeatureClass) arc_print("Gathering feature information.", True) # Get feature description and spatial reference information for tool use desc = arcpy.Describe(inFeatureClass) SpatialRef = desc.spatialReference shpType = desc.shapeType srName = SpatialRef.name arc_print( "The shape type is {0}, and the current spatial reference is: {1}".format(str(shpType), str(srName)), True) # Get mean center of feature class (for pointGeo) if arcpy.Exists(referenceFeatureClass) and referenceFeatureClass != "#": arc_print("Calculating the mean center of the reference feature class.", True) meanCenter = arcpy.MeanCenter_stats(referenceFeatureClass) else: arc_print("Calculating the mean center of the copied feature.", True) meanCenter = arcpy.MeanCenter_stats(inFeatureClass) fieldNames = getFields(inFeatureClass) arc_print("Getting point geometry from copied center.", True) pointGeo = copy.deepcopy(arcpy.da.SearchCursor(meanCenter, ["SHAPE@"]).next()[0]) # Only one center, so one recor # Check if the optional Street Length/ Lot Area field is used. idsAndFieldSearchNames = ["SHAPE@"] + fieldNames arc_print("The search cursor's fields and tags are:{0}".format(str(idsAndFieldSearchNames)), True) records = [] with arcpy.da.SearchCursor(inFeatureClass, idsAndFieldSearchNames) as cursorSearch: arc_print("Loading input feature classes rows into a new record list.", True) for search_row in cursorSearch: records.append(search_row) arc_print("Inserting new rows and geometries to new feature class.", True) count = 0 with arcpy.da.InsertCursor(tempOutFeature, idsAndFieldSearchNames) as cursorInsert: if desc.shapeType == "Polyline": for row in records: # Use two try statements, one time to try to catch the error count += 1 try: arc_print("A creating geometry dictionary for feature iteration: {0}.".format(str(count))) geoDict = CreateMainStreetBlockCEGeometry(pointGeo, lineLength(row, lengthField, lengthNum, idsAndFieldSearchNames), blockWidthValue) # print geoDict for key in geoDict.keys(): try: rowList = copyAlteredRow(row, idsAndFieldSearchNames, {"SHAPE@": geoDict[key], OldObjectIDName: count, GeometryName: str(key)}) cursorInsert.insertRow(rowList) except: arcpy.AddWarning("Passed line at iteration {0}.".format(str(count))) pass except: arcpy.GetMessage(2) arc_print("Failed on iteration {0}.".format(str(count)), True) pass else: arc_print("Input geometry is not a polyline. Check arguments.", True) arcpy.AddError("Input geometry is not a polyline. Check arguments.") arc_print("Projecting data into Web Mercator Auxiliary Sphere (a CityEngine compatible projection).", True) webMercatorAux = arcpy.SpatialReference(3857) arcpy.Project_management(OutPut, outFeatureClass, webMercatorAux) arc_print("Cleaning up intermediates.", True) arcpy.Delete_management(meanCenter) arcpy.Delete_management(OutPut) arcpy.DeleteField_management(inFeatureClass, OldObjectIDName) arcpy.DeleteField_management(inFeatureClass, GeometryName) del SpatialRef, desc, cursorSearch, webMercatorAux, cursorInsert
#______________________________________________________________________________# # # If Name is used for ParcelPIN make adjustments #______________________________________________________________________________# if ParcelPIN is "Name": arcpy.AlterField_management(PhotoFeatureClass, ParcelPIN, "Image_Name") else: pass SR = arcpy.Describe(Parcels) SRHelper = SR.spatialReference PhotoFeatureClass2 = """{}\\PointAttachments""".format(Geodatabase) arcpy.Project_management(PhotoFeatureClass, PhotoFeatureClass2, SRHelper) arcpy.DeleteIdentical_management(PhotoFeatureClass2, "Shape") arcpy.Delete_management(PhotoFeatureClass) EntGDB = arcpy.Describe(Geodatabase) EntGDB.workspaceType if EntGDB is 'RemoteDatabase': arcpy.RegisterAsVersioned_management(PhotoFeatureClass2) else: pass arcpy.AddMessage("Step 2: Converting Photos to points") # Load up the parcel dataset for the property association (and make a copy)
originCoordinate = str(desc.extent.lowerLeft) yAxisCoordinate = str( desc.extent.XMin) + " " + str(desc.extent.YMax + 10) oppositeCoorner = str(desc.extent.upperRight) fishnet =arcpy.CreateFishnet_management(fishnet_out,originCoordinate,yAxisCoordinate,cellSizeWidth,\ cellSizeHeight,numRows, numColumns, oppositeCoorner, labels,templateExtent, geometryType) #print r"fishnet created" ### out_coordinate_system = arcpy.Describe(urban_edge).spatialReference project_out = r"%s\\fGDB.gdb\\%s_fishnet_T%s_%s_project" % ( output, city, t, year) arcpy.Project_management(fishnet_out_gdb, project_out, out_coordinate_system) arcpy.AddField_management(project_out, "AreaH", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(project_out, "AreaH", "!Shape.Area@hectares!", "PYTHON", "") ### #with arcpy.da.SearchCursor(project_out,'AreaH') as cursor: # print max(cursor) max_total = max( (r[0] for r in arcpy.da.SearchCursor(project_out, ['AreaH']))) min_total = min( (r[0] for r in arcpy.da.SearchCursor(project_out, ['AreaH']))) factor = (max_total + min_total) / 2 #print "summed total %s " % factor
print outRotation if arcpy.Exists(outRotation): continue arcpy.SelectLayerByAttribute_management('fishnet', 'NEW_SELECTION', '"FID" = ' + str(FID)) rid = str(random.randint(10000,99999)) watershedCdlPrj = tempGdb + '/watershedCdlPrj_' + rid samplePts = tempGdb + '/samplePts_' + rid outRotation1 = tempGdb + '/outRotation1_' + rid outHigh1 = tempGdb + '/outHigh1_' + rid outLow1 = tempGdb + '/outLow1_' + rid cdlUrl = r'http://nassgeodata.gmu.edu:8080/axis2/services/CDLService/GetCDLFile?' arcpy.AddMessage("Projecting Area Of Interest to Cropland Data Layer projection...") print watershedCdlPrj arcpy.Project_management('fishnet', watershedCdlPrj, sr) ext = arcpy.Describe(watershedCdlPrj).extent if downloadBool == 'true': ping = Popen(['ping', '-n', '1', 'nassgeodata.gmu.edu'], startupinfo=startupinfo) ping.wait() if ping == 1: arcpy.AddError('The CropScape server is down. Please try again later, or download local Cropland Data Layers at http://www.nass.usda.gov/research/Cropland/Release/index.htm') arcpy.AddMessage("Downloading Cropland Data Layers...") years = range(int(yrStart), int(yrEnd) + 1) cdlTiffs = [] for year in years: year = str(year) clipUrl = cdlUrl\ + r'year='\
def make_identical_tif_extents(tif_list, temp_dir="tmp"): if os.path.exists(temp_dir): shutil.rmtree(temp_dir) os.mkdir(temp_dir) start_time = time.time() print("Setting extents to be identical on {} GeoTIFFS...".format(len(tif_list))) # Temporary variables output_tif_list = [] tif_list_fixed_extents = [] tif_properties = {} cell_extentX = [] cell_extentY = [] coords = set() coords_str = set() coords_str_l = [] coords_l = [] all_top = [] all_bottom = [] all_left = [] all_right = [] outlines_unchanged = [] arcpy.env.overwriteOutput = True main_coord_s = arcpy.Describe(tif_list[0]).spatialReference # Load tif properties that we care about into dictionary for a_tif in tif_list: coord, csX, csY = (arcpy.Describe(a_tif).spatialReference, arcpy.GetRasterProperties_management(a_tif, "CELLSIZEX"), arcpy.GetRasterProperties_management(a_tif, "CELLSIZEY")) cell_extentX.append(float(str(csX))) cell_extentY.append(float(str(csY))) coords.add(coord) coords_str.add(coord.name) coords_str_l.append(coord.name) coords_l.append(coord) tif_properties[a_tif] = [coord.name] print("Step 1/4: Setting projections to be identical....") # Reproject rasters to one projection j = 0 for a_tif in tif_properties.keys(): desc = arcpy.Describe(a_tif).baseName if not os.path.isfile(os.path.join(temp_dir, desc + "_reproject.tif")): arcpy.ProjectRaster_management(a_tif, os.path.join(temp_dir, desc + "_reproject.tif"), main_coord_s) tif_properties[os.path.join(temp_dir, desc + "_reproject.tif")] = main_coord_s del tif_properties[a_tif] print("Step 2/4: Setting cell sizes to be identical....") # Set cell sizes to be identical if necessary if len(set(cell_extentX)) > 1 or len(set(cell_extentY)) > 1: x_freq = max(set(cell_extentX), key=cell_extentX.count) y_freq = max(set(cell_extentY), key=cell_extentY.count) tif_list = tif_properties.keys() for a_tif in tif_list: desc = arcpy.Describe(a_tif).baseName if float(str(arcpy.GetRasterProperties_management(a_tif, "CELLSIZEX"))) != x_freq or float(str(arcpy.GetRasterProperties_management(a_tif, "CELLSIZEY"))) != y_freq: if not os.path.isfile(os.path.join(temp_dir, desc + "_resample.tif")): arcpy.Resample_management(a_tif,os.path.join(temp_dir, desc + "_resample.tif"), x_freq) tif_properties[os.path.join(temp_dir, desc + "_resample.tif")] = main_coord_s try: del tif_properties[a_tif] except: pass # Generate polygon extent shape for each tif print("Step 3/4: Generating minimum bounding polygon....") for a_tif in tif_properties.keys(): desc = arcpy.Describe(a_tif).baseName arcpy.RasterDomain_3d(a_tif, os.path.join(temp_dir, desc + "_Outline_notproj.shp"), "POLYGON") arcpy.Project_management(os.path.join(temp_dir, desc + "_Outline_notproj.shp"),os.path.join(temp_dir, desc + "_Outline.shp"), main_coord_s) outlines_unchanged.append(os.path.join(temp_dir, desc + "_Outline.shp")) for x in range(0, len(outlines_unchanged)): this_outline = outlines_unchanged[x] if x == 0: outline_to_clip_to = outlines_unchanged[x + 1] outline_to_save_to = os.path.join(temp_dir, "final_cutout_tmp.shp") arcpy.Clip_analysis(this_outline, outline_to_clip_to, outline_to_save_to) arcpy.CopyFeatures_management(outline_to_save_to, os.path.join(temp_dir, "final_cutout.shp")) else: outline_to_clip_to = os.path.join(temp_dir, "final_cutout.shp") outline_to_save_to = os.path.join(temp_dir, "final_cutout_tmp.shp") arcpy.Clip_analysis(this_outline, outline_to_clip_to, outline_to_save_to) arcpy.CopyFeatures_management(outline_to_save_to, outline_to_clip_to) desc = arcpy.Describe(os.path.join(temp_dir, "final_cutout.shp")) bounding = "{} {} {} {}".format(desc.extent.XMin, desc.extent.YMin, desc.extent.XMax, desc.extent.YMax) print("Step 4/4: Clipping rasters to minimum bounding polygon....") for a_tif in tif_properties.keys(): desc = arcpy.Describe(a_tif).baseName ## Reproject the shapefile to be the same projection as the input raster coord_system = arcpy.Describe(a_tif).spatialReference arcpy.Project_management(os.path.join(temp_dir, "final_cutout.shp"), os.path.join(temp_dir, "final_cutout_proj.shp"), main_coord_s) if not os.path.isfile(os.path.join(temp_dir, desc + "_clip.tif")): outExtract = arcpy.sa.ExtractByMask(a_tif, os.path.join(temp_dir, "final_cutout_proj.shp")) outExtract.save(os.path.join(temp_dir, desc + "_clip.tif")) tif_list_fixed_extents.append(os.path.join(temp_dir, desc + "_clip.tif")) end_time = time.time() t = gt.readable_time(start_time, end_time) output_tif_list = tif_list_fixed_extents print("{} GeoTIFFs processed to have identical extents in {} days, {}:{}:{}".format(len(tif_list), t['dd'], t["hh"], t["mm"], t['ss'])) return output_tif_list
data = json.load(f) return data d = read_config(coffee_cfg) print(d['data']['out_cs']) proj_filename = 'F:/GIS/Pratt/Ind. Study - Arc/CIAT Data/Coffee Points/AEA Projected/' + s + '_proj' out_cs = d['data']['out_cs'] transform = '' in_cs = d['data']['in_cs'] shp_preserve = 'NO_PRESERVE_SHAPE' max_dev = '' vertical = 'NO_VERTICAL' arcpy.Project_management( out_layer, proj_filename, out_cs, transform, in_cs, shp_preserve, max_dev, vertical, ) arcpy.CopyFeatures_management(out_layer, saved_layer) # Save layer to file arcpy.SaveToLayerFile_management(out_layer, saved_layer)
st = st_tuple[c] urban_area_tracts = "urban_area_tracts_" + str(c) + ".shp" urban_area_join = "urban_area_lehd_join_" + str(c) + ".shp" urban_area_tracts_prj = "urban_area_tracts_prj.shp" uat_emp_hspt = "uat_emp_hspt_" + str(c) + ".shp" print "(" + str(c) + ") " + ua print "- Project" # Process: Project #arcpy.Project_management(urban_area_tracts_0, urban_area_tracts_prj_0, "PROJCS['NAD_1983_UTM_Zone_18N',GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',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',-75.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]", "", "GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]") utm_zone = 'NAD 1983 UTM Zone ' + long_dict[ua] + 'N' print "- " + utm_zone outCS = arcpy.SpatialReference(utm_zone) arcpy.Project_management(urban_area_tracts, urban_area_tracts_prj, outCS) print "- Add Area Field" # Process: Add Field arcpy.AddField_management(urban_area_tracts_prj, "AREA", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") print "- Compute Area" # Process: Calculate Field arcpy.CalculateField_management(urban_area_tracts_prj, "AREA", "!SHAPE.AREA@SQUAREMILES!", "PYTHON_9.3") print "- Join to LEHD" # Process: Feature Layer arcpy.MakeFeatureLayer_management(urban_area_tracts_prj, layerName) # Process: Add Join
fc_pl = os.path.join(folder_shpfile, shp_pl) tb_pdnm = os.path.join(folder_shpfile, dbf_pdnm) tb_plnm = os.path.join(folder_shpfile, dbf_plnm) # create temp fgdb for data preparing arcpy.env.workspace = os.path.join(folder_shpfile, fgdb_tmp) if not arcpy.Exists(arcpy.env.workspace): arcpy.CreateFileGDB_management(folder_shpfile, fgdb_tmp) # project to NAD 1983 HARN StatePlane Washington South FIPS 4602 (US Feet) msg = '%s Project source shapefile %s to fgdb %s with datum transformation WGS_1984_(ITRF00)_To_NAD_1983_HARN ...' % ( datetime.datetime.now(), fc_pd, arcpy.env.workspace) print(msg) arcpy.Project_management(fc_pd, 'pd', arcpy.SpatialReference(2927), 'WGS_1984_(ITRF00)_To_NAD_1983_HARN') msg = '%s Project source shapefile %s to fgdb %s with datum transformation WGS_1984_(ITRF00)_To_NAD_1983_HARN ...' % ( datetime.datetime.now(), fc_pl, arcpy.env.workspace) print(msg) arcpy.Project_management(fc_pl, 'pl', arcpy.SpatialReference(2927), 'WGS_1984_(ITRF00)_To_NAD_1983_HARN') # add/calculate fields for 'ReleaseVersion', 'FeatureType', 'AreaSqMi', 'GDLPublishDate' msg = '%s calculate pd ReleaseVersion, FeatureType, AreaSqMi, GDLPublishDate ...' % datetime.datetime.now( ) print(msg) arcpy.CalculateField_management('pd', 'ReleaseVersion', "'" + version + "'") arcpy.CalculateField_management('pd', 'FeatureType', "'Postal Code'") date_now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') arcpy.CalculateField_management('pd', 'GDLPublishDate', "'" + date_now + "'") arcpy.CalculateField_management('pd', 'AreaSqMi', "!SHAPE_Area! / 27880000")
print "Step 1 completed at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p") ## --------------------------------------------------------------------------- ## 2. Project the polygons ## Description: Project the land-use dataset for the Mexico RGB to North America Albers Equal Area Conic print "\nStep 2 Project the polygon starts at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p") outCS = arcpy.SpatialReference("North America Albers Equal Area Conic") for fc in fcList: root = os.path.splitext(fc)[0] name = os.path.split(root)[1] projFile = os.path.join(out_gdb, name) arcpy.Project_management(fc, projFile, outCS) projList.append(projFile) print "Projection" , fc, "completed at" , datetime.datetime.now().strftime("%I:%M:%S%p") print "Step 2 Project completed at", datetime.datetime.now().strftime("%I:%M:%S%p") ## --------------------------------------------------------------------------- ## 3. Clip ## Description: Clip the MX INEGI dataset for the study area. print "\nStep 3 starts at", datetime.datetime.now().strftime("%A, %B %d %Y %I:%M:%S%p") # Create the clip_features folderShapefiles = "C:\\GIS_RGB\\Geodatabase\\rgb_bound\\" listfc = ["RGB_Ses_na_albers.shp"]
for f in allbutpos: fromShp = allshp[f] # reproject data if necessary coordFrom = arcpy.Describe(fromShp).spatialReference coordFrom_str = coordFrom.exportToString() fromShpProj = os.path.splitext(fromShp)[0] + "_proj.shp" if (coordFrom_str[0:40] == coordTo_str[0:40]) == False: if (os.path.isfile(fromShpProj)): arcpy.Delete_management(fromShpProj) arcpy.Project_management(fromShp, fromShpProj, coordTo) fromShp = fromShpProj # change geometry if necessary interm = os.path.splitext(fromShp)[0] + "_interm.shp" if fromGeometries[f] != fromGeometries[pos]: if (os.path.isfile(interm)): arcpy.Delete_management(interm) if fromGeometries[pos] == "Point": # check if feature midpoints or vertices should be converted to points if userTab[row][0] in verTab: arcpy.FeatureVerticesToPoints_management(fromShp, interm, "ALL")
dem_clipped, aoi, nodata_value="-3.402823e+38", clipping_geometry="NONE", maintain_clipping_extent="NO_MAINTAIN_EXTENT" ) else: # set the dem_clipped to original dem in the case it doesn't exist dem_clipped = dem # reproject the datasets to something with common units - dem is in meters, # so use utm zone 19 utmz19 = ea.sr.get_sr_nad83_utm_z19() nhd_flowline_p = str(here('./results/nhd_p.shp', warn=False)) arcpy.Project_management(nhd_flowline, nhd_flowline_p, utmz19) # convert nhd flowline to raster with same cellsize as dem nhd_flowline_r = str(here('./results/nhd_f_raster.tif', warn=False)) arcpy.PolylineToRaster_conversion( nhd_flowline_p, "Enabled", nhd_flowline_r, "MAXIMUM_LENGTH", "NONE") # reclass to 0 / height nhd_flowline_rc = str(here('./results/nhd_f_rasterrc.tif', warn=False)) stream_burn_height = 5
lstFCs = arcpy.ListFeatureClasses("*") for fc in lstFCs: #fcList.append(os.path.join(folder + "\\" + fc)) print fc dsc = arcpy.Describe(fc) if dsc.spatialReference.Name == "Unknown": print('skipped this fc due to undefined coordinate system: ' + infc) else: print dsc.spatialReference.Name print dsc.spatialReference.Name.find("1983") # Determine the new output feature class path and name newname = fc.strip('.shp') print newname outfc = os.path.join(outWorkspace, newname) # Set output coordinate system prjFile = "C:\Program Files (x86)\ArcGIS\Desktop10.0\Coordinate Systems\WGS 1984 Web Mercator (Auxiliary Sphere).prj" outCS = arcpy.SpatialReference(prjFile) print outfc if dsc.spatialReference.Name.find("1983") > 1: print "This has an 1983 Datum" arcpy.Project_management(fc, outfc, outCS, "NAD_1983_To_WGS_1984_1") if dsc.spatialReference.Name.find("1984") > 1: print "This has an 1984 Datum" arcpy.Project_management(fc, outfc, outCS) print print print
'LATITUDE', 'boxlayer', xycs) # convert event layer to preliminary line feature class with PointsToLine_management arcpy.PointsToLine_management('boxlayer', 'xxMapOutline') # densify MapOutline arcpy.Densify_edit('xxMapOutline', 'DISTANCE', 0.0001) # project to correct spatial reference ### THIS ASSUMES THAT OUTPUT COORDINATE SYSTEM IS HARN AND WE ARE IN OREGON OR WASHINGTON!! if isNAD27: geotransformation = 'NAD_1927_To_NAD_1983_NADCON;NAD_1983_To_HARN_OR_WA' else: geotransformation = 'NAD_1983_To_HARN_OR_WA' geotransformation = '' arcpy.Project_management('xxMapOutline', 'MapOutline', outSpRef, geotransformation, xycs) ## TICS # calculate minTicLong, minTicLat, maxTicLong, maxTiclat ticInterval = ticInterval / 60.0 # convert minutes to degrees minTicLong = int(round(0.1 + minLong // ticInterval)) maxTicLong = int(round(1.1 + maxLong // ticInterval)) minTicLat = int(round(0.1 + minLat // ticInterval)) maxTicLat = int(round(1.1 + maxLat // ticInterval)) if minTicLong < 0: minTicLong = minTicLong + 1 if maxTicLong < 0: maxTicLong = maxTicLong + 1 # make xy file for tics addMsgAndPrint(' writing tic file') genf = open(scratch + '/xxxtics.csv', 'w')
import arcpy import arcgisscripting gp = arcgisscripting.create() arcpy.CheckOutExtension("3D") gp.workspace = r"\\server23\Tasks\NightlyWeatherShapefile\Shapefile" #Project Points From HRAP to State Plane arcpy.Project_management( in_dataset="/nws_precip.shp", out_dataset="/nws_precip_projected.shp", out_coor_system= "GEOGCS['HRAP_Sphere',DATUM['<custom>',SPHEROID['<custom>',6371200.0,0.0]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", transform_method="#", in_coor_system= "GEOGCS['HRAP_Sphere',DATUM['<custom>',SPHEROID['<custom>',6371200.0,0.0]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]" ) print "Projecting Points Completed" #Create Tin from Points arcpy.CreateTin_3d( "E:/Tasks/NightlyWeatherShapefile/Shapefile/precipitation", "PROJCS['NAD_1983_StatePlane_Nebraska_FIPS_2600_Feet',GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Lambert_Conformal_Conic'],PARAMETER['False_Easting',1640416.666666667],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-100.0],PARAMETER['Standard_Parallel_1',40.0],PARAMETER['Standard_Parallel_2',43.0],PARAMETER['Latitude_Of_Origin',39.83333333333334],UNIT['Foot_US',0.3048006096012192]]", "C:/Tasks/NightlyWeatherShapefile/Shapefile/nws_precip_projected.shp Globvalue masspoints <None>", "DELAUNAY") print "Creating Tin from Points Completed" #Create Contours from Tin arcpy.SurfaceContour_3d(in_surface="/precipitation", out_feature_class="/Contours.shp", interval="1",
print("Please choose a valid analysis mode ") #define spatial reference presets spatialref_default = arcpy.SpatialReference(4326) spatialref_proj = arcpy.SpatialReference(epsg) spatial_ref = arcpy.Describe(inputpath + points) #check projection of point shapefile and set projection if unknown if spatial_ref.name == "Unknown": print( "The source points file has an unknown spatial reference, setting to default projection (EPSG 4326) " ) arcpy.DefineProjection_management(points, spatialref_default) #reproject shapefile to correct projection points_projected = "sourcepoints_projected.shp" arcpy.Project_management(inputpath + points, inputpath + points_projected, spatialref_proj) if binningmode == 0: #calculate interval values and time interval counts getintervals_time(sealvl, time, intervals) elif binningmode == 1: getintervals_sealvl(sealvl, time, intervals) #import interval file generated by getintervals subroutine intervalfile = pandas.read_csv(outpath + 'intervals.csv') #run subroutine to generate sea level rasters for each interval makerasters(intervalfile, inputraster, epsg) #run subroutine to generate distance matrices for each interval if mode == 0: islandmode(intervalfile, points_projected) calcmatrices_island( outpath, intervalfile ) #run subroutine to calculate time-weighted average across distance matrices