def TIN2TIF(tin): arcpy.env.extent = arcpy.Extent(624127.347083, 2095613.485647, 2684127.347083, 3259613.485647) arcpy.TinRaster_3d(in_tin=wrkdir+"\\"+tin, out_raster=wrkdir+"\\"+tin+".tif", data_type="FLOAT", method="LINEAR", sample_distance="CELLSIZE 200", z_factor="1")
def tin2raster(self, interpolation_method="LINEAR", sampling_method="OBSERVATIONS"): print(" * converting tin to raster ...") arcpy.env.outputCoordinateSystem = self.sr arcpy.TinRaster_3d(self.tin, self.raster_tif, data_type="FLOAT", method=interpolation_method, sample_distance=sampling_method, z_factor=1) print(" - OK")
def tin_to_raster(tin, cs, out, template=None, snapRst=None): if template: tempEnvironment0 = arcpy.env.extent arcpy.env.extent = template if snapRst: tempSnap = arcpy.env.snapRaster arcpy.env.snapRaster = snapRst arcpy.TinRaster_3d(tin, out, "FLOAT", "LINEAR", "CELLSIZE {}".format(str(cs)), "1") if template: arcpy.env.extent = tempEnvironment0 if snapRst: arcpy.env.snapRaster = tempSnap return out
arcpy.MakeFeatureLayer_management(endPoints, endPointsLyr) IDs = [] with arcpy.da.SearchCursor(endPointsLyr, ('RIGHT_FID', )) as cursor: for row in cursor: if row not in IDs: IDs.append(row) IDlist = [] for values in IDs: for x in values: IDlist.append(x) for patchID in IDlist: selection = arcpy.SelectLayerByAttribute_management( endPointsLyr, "ADD_TO_SELECTION", 'RIGHT_FID = ' + str(patchID)) outTIN = scratchFolder + '\TIN_' + str(patchID) depthfield = ' Heights' mp = ' Mass_Points' none = ' <None>' inFeatures = str(selection) + depthfield + mp + none arcpy.CreateTin_3d(outTIN, '', inFeatures, "DELAUNAY") arcpy.TinRaster_3d( outTIN, patchOutputFolder + '\Patch_' + str(patchID) + '.tif', "FLOAT", '', "CELLSIZE " + str(cellsize), ) arcpy.SelectLayerByAttribute_management(endPointsLyr, "CLEAR_SELECTION") print('All processes complete')
ymax = int(ymaxFloat) arcpy.AddMessage("X Min, X Max, Y Min, and Y Max are...") arcpy.AddMessage(xmin) arcpy.AddMessage(xmax) arcpy.AddMessage(ymin) arcpy.AddMessage(ymax) arcpy.AddMessage("") # arcpy.env.extent = arcpy.Extent(xmin, ymin, xmax, ymax) # ############################################### # create DEM outRaster = str(outFolder + "\\" + "Seg_" + inSegment + "_" + inYear + "_" + CellSizeName + ".tif") arcpy.AddMessage("output raster is: " + outRaster) CellSizeStatement = str("CELLSIZE " + CellSize) arcpy.TinRaster_3d(inTIN, outRaster, "FLOAT", "LINEAR", CellSizeStatement, 1) # # create mask for area of DEM RasterMask = str(outFolder + "\\" + "Seg_" + inSegment + "_" + inYear + "_mask.tif") arcpy.gp.Divide_sa(outRaster, outRaster, RasterMask) RasterMaskInt = str(outFolder + "\\" + "Seg_" + inSegment + "_" + inYear + "_" + CellSizeName + "_maskInt.tif") arcpy.gp.Int_sa(RasterMask, RasterMaskInt) arcpy.AddMessage("output raster mask is: " + RasterMaskInt) # # convert raster mask to polygon #PolyMask = str(workspaceGDB + "\\" + "Seg_" + inSegment + "_" + inYear + "_" + CellSizeName + "_mask_poly") PolyMask = str(workspaceGDB + "\\" + "Seg_" + inSegment + "_" + inYear + "_" + CellSizeName + "_mask_poly") arcpy.AddMessage("output polygon mask: " + PolyMask) arcpy.AddMessage(PolyMask) arcpy.RasterToPolygon_conversion(RasterMaskInt, PolyMask, "NO_SIMPLIFY", "Value")
# Step 3: Create TINs from depth and velocity point shapefiles # Create TINs from model points shapefile print('Creating TINs from model XY point shapefiles...') mod_depth = arcpy.CreateTin_3d('mod_depth', spatial_reference=spat_ref, in_features='%s D Mass_Points' % mod_points, constrained_delaunay='Delaunay') mod_vel = arcpy.CreateTin_3d('mod_vel', spatial_reference=spat_ref, in_features='%s V Mass_Points' % mod_points, constrained_delaunay='Delaunay') # Step 4: Convert TINS to rasters (depth and velocity) # Convert TINs to rasters print('Converting TINs to rasters...') depth_ras_full = arcpy.TinRaster_3d(mod_depth, 'depth_ras_full.tif', sample_distance='CELLSIZE', sample_value=3) vel_ras_full = arcpy.TinRaster_3d(mod_vel, 'vel_ras_full.tif', sample_distance='CELLSIZE', sample_value=3) # Step 5: Clip rasters to the boundary shapefile # Clipping rasters print('Clipping depth and velocity rasters to boundary shapefile...') extents = arcpy.Describe(bndry_shp).extent rectangle = '%s %s %s %s' % (extents.XMin, extents.YMin, extents.XMax, extents.YMax) arcpy.Clip_management(in_raster=depth_ras_full, rectangle=rectangle, out_raster='depth_ras.tif', in_template_dataset=bndry_shp, clipping_geometry='ClippingGeometry') arcpy.Clip_management(vel_ras_full, rectangle, out_raster='vel_ras.tif', in_template_dataset=bndry_shp, clipping_geometry='ClippingGeometry') depth_ras = Raster('depth_ras.tif') vel_ras = Raster('vel_ras.tif')
# Create TIN arcpy.AddMessage("Creating TIN for {0}".format(stage)) if stage == "MIN_Z_Value": stage_name_for_table = "MIN_Z_Value" else: stage_name_for_table = "{0}.{1}".format(Table, stage) expression = "{0} <None> Soft_Clip <None>;{1} {2} Mass_Points <None>;{3} {4} Hard_Line <None>".format( Reaches, New_CrossSections, stage_name_for_table, New_CrossSections, stage_name_for_table) arcpy.CreateTin_3d(TIN, spatial_ref, expression, "CONSTRAINED_DELAUNAY") # TIN to Raster arcpy.AddMessage("Converting TIN to raster for {0}".format(stage)) input_cell_size = "CELLSIZE {0}".format(Cell_Size) arcpy.TinRaster_3d(TIN, RasterFromTIN, "FLOAT", "LINEAR", input_cell_size, "1") # Raster subtraction arcpy.AddMessage( "Subtracting the raster from TIN with the input DEM for {0}".format( stage)) arcpy.Minus_3d(RasterFromTIN, DEM, Subtracted) # Reclassify raster arcpy.AddMessage( "Reclassifing the subtracted raster for {0}".format(stage)) arcpy.Reclassify_3d(Subtracted, "Value", "-999 0.01 1;0.01 999 0", Reclassified, "DATA") # Extract by Attributes arcpy.AddMessage("Extracting by attributes for {0}".format(stage))
def tinraster_3d(self, layer_name, input_fc_name, raster_field_name): self.layer_name = layer_name self.input_fc_name = input_fc_name self.raster_field = raster_field_name # Check out any necessary licenses print "Checking out extension licenses..." arcpy.CheckOutExtension("3D") arcpy.CheckOutExtension("spatial") # overwrite output arcpy.env.overwriteOutput = True # tin outTIN = os.getcwd() + r'\Data\tin_' + self.layer_name # raster outRASTER = os.getcwd() + r'\Data\RST_' + self.layer_name input_fc = join(os.getcwd(), 'Precip.gdb', layer_name) print(input_fc) try: # Process: Create TIN print "Creating TIN..." arcpy.CreateTin_3d( outTIN, "PROJCS['NAD_1983_StatePlane_Texas_Central_FIPS_4203_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',2296583.333333333]," "PARAMETER['False_Northing',9842500.0]," "PARAMETER['Central_Meridian',-100.3333333333333]," "PARAMETER['Standard_Parallel_1',30.11666666666667]," "PARAMETER['Standard_Parallel_2',31.88333333333333]," "PARAMETER['Latitude_Of_Origin',29.66666666666667]," "UNIT['Foot_US',0.3048006096012192]]", "'" + self.input_fc_name + "' " + self.raster_field + " Mass_Points <None>", "DELAUNAY") # arcpy.CreateTin_3d(outTIN, "PROJCS['NAD_1983_StatePlane_Texas_Central_FIPS_4203_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',2296583.333333333]," # "PARAMETER['False_Northing',9842500.0]," # "PARAMETER['Central_Meridian',-100.3333333333333]," # "PARAMETER['Standard_Parallel_1',30.11666666666667]," # "PARAMETER['Standard_Parallel_2',31.88333333333333]," # "PARAMETER['Latitude_Of_Origin',29.66666666666667]," # "UNIT['Foot_US',0.3048006096012192]]", # "'Database Connections\\Connection to FWSDE.sde\\sde_wjt.\"FREESE\\wjt\".hrap\\" # "sde_wjt.\"FREESE\\wjt\"." + self.input_fc_name + "' " + self.raster_field + # " Mass_Points <None>", "DELAUNAY") # Process: TIN to Raster print "Creating raster..." # typical cellsize is 12500 arcpy.TinRaster_3d(outTIN, outRASTER, "FLOAT", "LINEAR", "CELLSIZE 5000", "1") self.run_status = 'OK' except Exception as e: self.run_status = e root = tk.Tk() # allows tkMessageBox to be shown without displaying Tkinter root window root.withdraw() tkMessageBox.showinfo("Python error", e) return self.run_status return self.run_status
#output folder arcpy.env.workspace = 'I:\\asignaturas\\sig-I\\2012-2013\\cuatrimestreB\\teoria\\MT7\\salida' #tool parameters tin = 'tin' grid = 'grid' data_type = 'FLOAT' interpolation_method = 'LINEAR' sampling_method = 'CELLSIZE 10' factor = 1 if arcpy.CheckExtension("3D") == "Available": arcpy.CheckOutExtension("3D") #TIN to GRID conversion arcpy.TinRaster_3d(tin, grid, data_type, interpolation_method, sampling_method, factor) arcpy.CheckInExtension("3D") else: print('Licencia 3D no disponible') #------------------------------------------------------------------------------- # SLOPE MAP #------------------------------------------------------------------------------- #importing module import arcpy #enable output overwrite arcpy.env.overwriteOutput = True #output folder arcpy.env.workspace = 'I:\\asignaturas\\sig-I\\2012-2013\\cuatrimestreB\\teoria\\MT7\\salida'
def calculate_height(lc_input_features, lc_ws, lc_tin_dir, lc_input_surface, lc_output_features, lc_log_dir, lc_debug, lc_memory_switch): try: # create dem desc = arcpy.Describe(lc_input_features) if desc.spatialReference.linearUnitName in ['Foot_US', 'Foot']: unit = 'Feet' else: unit = 'Meters' # Generate raster from lasd if arcpy.Exists(lc_input_features): if arcpy.Exists(lc_output_features): arcpy.Delete_management(lc_output_features) # make a copy bridge_polys = lc_output_features + "_height" if arcpy.Exists(bridge_polys): arcpy.Delete_management(bridge_polys) arcpy.CopyFeatures_management(lc_input_features, bridge_polys) # create string field for featureFID oidFieldName = arcpy.Describe(bridge_polys).oidFieldName common_lib.delete_add_field(bridge_polys, esri_featureID, "TEXT") arcpy.CalculateField_management(bridge_polys, esri_featureID, "!" + oidFieldName + "!", "PYTHON_9.3") msg_body = create_msg_body( "Calculating height above surface for: " + common_lib.get_name_from_feature_class(lc_input_features), 0, 0) msg(msg_body) # create bridge tin out_tin = os.path.join(lc_tin_dir, "bridge_tin") if arcpy.Exists(out_tin): arcpy.Delete_management(out_tin) msg_body = create_msg_body( "Creating raster for: " + common_lib.get_name_from_feature_class(lc_input_features), 0, 0) msg(msg_body) arcpy.CreateTin_3d( out_tin, arcpy.Describe(bridge_polys).spatialReference, "{} Shape.Z Hard_Clip <None>".format(bridge_polys), "DELAUNAY") # turn to raster if 0: bridge_raster = "in_memory/bridge_raster" else: bridge_raster = os.path.join(lc_ws, "bridge_raster") if arcpy.Exists(bridge_raster): arcpy.Delete_management(bridge_raster) # use same cell size as input surface cell_size = arcpy.GetRasterProperties_management( lc_input_surface, "CELLSIZEX")[0] dataType = "FLOAT" method = "LINEAR" sampling = "CELLSIZE " + str(cell_size) zfactor = "1" arcpy.TinRaster_3d(out_tin, bridge_raster, dataType, method, sampling, zfactor) add_minimum_height_above_water_surface(lc_ws, bridge_polys, bridge_raster, lc_input_surface, lc_memory_switch) # create point file for labeling if lc_memory_switch: bridge_points = "in_memory/bridge_points" else: bridge_points = os.path.join(lc_ws, "bridge_points") if arcpy.Exists(bridge_points): arcpy.Delete_management(bridge_points) arcpy.FeatureToPoint_management(bridge_polys, bridge_points, "INSIDE") bridge_points3D = lc_output_features + "_points_3D" if arcpy.Exists(bridge_points3D): arcpy.Delete_management(bridge_points3D) # create 3D point arcpy.FeatureTo3DByAttribute_3d(bridge_points, bridge_points3D, zmin_field) # add unit field common_lib.delete_add_field(bridge_points3D, esri_unit, "TEXT") expression = """{} IS NOT NULL""".format( arcpy.AddFieldDelimiters(bridge_points3D, has_field)) # select all points with good elevation values local_layer = common_lib.get_name_from_feature_class( bridge_points3D) + "_lyr" select_lyr = arcpy.MakeFeatureLayer_management( bridge_points3D, local_layer).getOutput(0) arcpy.SelectLayerByAttribute_management(select_lyr, "NEW_SELECTION", expression, None) z_unit = common_lib.get_z_unit(bridge_points3D, lc_debug) if z_unit == "Meters": expression = "'m'" else: expression = "'ft'" arcpy.CalculateField_management(select_lyr, esri_unit, expression, "PYTHON_9.3") arcpy.SelectLayerByAttribute_management(select_lyr, "CLEAR_SELECTION") common_lib.delete_fields(bridge_polys, [min_field, zmin_field]) common_lib.delete_fields(bridge_points3D, [min_field, zmin_field]) return bridge_polys, bridge_points3D else: msg_body = create_msg_body( "Couldn't find input feature class: " + str(lc_input_features), 0, 0) msg(msg_body, WARNING) return None except arcpy.ExecuteError: # Get the tool error messages msgs = arcpy.GetMessages(2) arcpy.AddError(msgs) except Exception: e = sys.exc_info()[1] arcpy.AddMessage("Unhandled exception: " + str(e.args[0]))
#Create TINs for n in xrange(1, len(data) + 1): shp = locshp + data2[n - 1] + ".shp" #breakl = locshp + data2[n-1] + "_Cliff.shp" TIN = loctin + data[n - 1] RAS = locras + data[n - 1] arcpy.CreateTin_3d(TIN, sr, [[shp, "Z", "masspoints"]], "CONSTRAINED_DELAUNAY") arcpy.DelineateTinDataArea_3d(TIN, tin_length) print data[n - 1] + ' TIN created' #Tins to rasters for n in xrange(1, len(data) + 1): TIN = loctin + data[n - 1] RAS = locras + data[n - 1] arcpy.TinRaster_3d(TIN, RAS, "FLOAT", "LINEAR", "CELLSIZE 1.0") #1 m cell size print data[n - 1] + ' raster created' else: print "Using Rasters created from previous 'Total Analysis' Run" #Merge rasters for n in xrange(1, len(data) + 1): if AnalysisType == "Tidal": RAS = locras + 'm_' + data[n - 1] else: RAS = locras + data[n - 1] mRAS = locras + rastype + data[n - 1] temp = "in_memory/t1" + integ tempn = "t1" + integ mRASname = rastype + data[n - 1] if AnalysisType == "Tidal":
# Create a Triangular Irregular Network (TIN) model of the terrain ##################### arcpy.env.workspace = r"E:/GitHub/terrainModeling/chp12data.gdb" """ DEM to TIN The TIN data cannot be saved in a geodatabase, so the output data should be put into a folder e.g. E:/GitHub/terrainModeling/chp12data.gdb/tin """ arcpy.RasterTin_3d("dem", "tin") """ TIN to DEM The cell size of the new DEM is 50 meters, values are in the float type, and the methos used to raster the DEM is linear interpolation """ arcpy.TinRaster_3d(in_tin=r"chp12data.gdb/tin", out_raster="demFromTIN", \ data_type="FLOAT", method="LINEAR", \ sample_distance="CELLSIZE 50",z_factor="1") # Create contour lines ################################################################## """ The input is "dem" and the output is "contour". The contour is in 10 meter intervals and starts from 330 meters. """ arcpy.Contour_3d(in_raster="dem", out_polyline_features=" contour", \ contour_interval="10", base_contour="330", z_factor="1") # Create slope raster ################################################################### # the input is DEM, and slope is in the unit of degrees slopely = arcpy.sa.Slope("dem", "DEGREE") # save the slope layer into geodatabase (path has been set above) slopely.save("slope")
def runScript(uploaderpk): print("Starting script") startTime = time.time() arcpy.env.overwriteOutput = True arcpy.env.cellSize = 1 # Activate spatial analyst extension if arcpy.CheckExtension("Spatial") == "Available": arcpy.CheckOutExtension("Spatial") if arcpy.CheckExtension("3D") == "Available": arcpy.CheckOutExtension("3D") # basePath = .../apps/findbestroute/workfiles/ global basePath sleep(2) basePath = os.path.join(settings.PROJECT_PATH, 'apps', 'findbestroute', 'workfiles') env.workspace = basePath sleep(2) mxd = arcpy.mapping.MapDocument(os.path.join(basePath, r'mapdocument.mxd')) onlyfiles = [] kart_path = None for file in os.listdir( os.path.join(settings.PROJECT_PATH, r"files", r"user_" + str(uploaderpk))): if file.endswith(".shp"): onlyfiles.append( os.path.join(settings.PROJECT_PATH, r"files", r"user_" + str(uploaderpk), file)) elif file.endswith(".jpg"): kart_path = os.path.join(settings.PROJECT_PATH, r"files", r"user_" + str(uploaderpk), file) for el in onlyfiles: print("File: " + el.__str__()) print("Map file: " + kart_path.__str__()) arealsymboler, linjesymboler, punktsymboler, breakBoolean = geometryType( onlyfiles) if (breakBoolean): print( "Datafiles not containing all shapefiles( either point, polyline or polygon)" ) return kart = kart_path #os.path.join(settings.PROJECT_PATH, r"apps", r"findbestroute", r"workfiles", r"inData", r"kart.jpg") #geoProcess(kart_path, arealsymboler) start = getStart(punktsymboler) destination = getDestination(punktsymboler) mask = setMask(start, destination) arcpy.env.mask = os.path.join(basePath, r"Trash", r"mask.shp") utsnitt = getExtentOfMap(linjesymboler) hoydedata = arcpy.Clip_analysis( in_features=os.path.join(basePath, r"hoydeData", r"trondheiml.shp"), clip_features=utsnitt, out_feature_class=os.path.join(basePath, r"Trash", r"hoydedata.shp"), cluster_tolerance="") #Klipper til symbolene etter mask ar = arcpy.Clip_analysis(in_features=arealsymboler, clip_features=mask, out_feature_class=os.path.join( basePath, r"Trash", r"a5"), cluster_tolerance="") ln = arcpy.Clip_analysis(in_features=linjesymboler, clip_features=mask, out_feature_class=os.path.join( basePath, r"Trash", r"a6"), cluster_tolerance="") pt = arcpy.Clip_analysis(in_features=punktsymboler, clip_features=mask, out_feature_class=os.path.join( basePath, r"Trash", r"a7"), cluster_tolerance="") #Runde ned alle symboler floorSymbols(ar) floorSymbols(ln) floorSymbols(pt) #Lage buffer paa linjer som er lik bredden de skal ha fieldnames = [field.name for field in arcpy.ListFields(ln)] if not "WIDTH" in fieldnames: arcpy.AddField_management(in_table=ln, field_name="WIDTH", field_type="DOUBLE") symbols = [ 106, 107, 201, 203, 304, 305, 307, 502, 503, 504, 505, 506, 507, 508, 509 ] width = [2, 2, 4, 4, 2, 2, 1, 6, 4, 3, 2.5, 2, 2, 2, 2] features = arcpy.UpdateCursor(ln) for feature in features: if feature.SYMBOL in symbols: n = symbols.index(feature.SYMBOL) feature.WIDTH = width[n] features.updateRow(feature) del feature, features, n ln_buff = arcpy.Buffer_analysis(in_features=ln, out_feature_class=os.path.join( basePath, r"Trash", r"a8"), buffer_distance_or_field="WIDTH", line_side="FULL", line_end_type="FLAT", dissolve_option="LIST", dissolve_field="SYMBOL") #Hente ut alle forbudte symboler forbiddenArea = arcpy.Select_analysis( in_features=ar, out_feature_class=os.path.join(basePath, r"Trash", r"a9"), where_clause= '"SYMBOL" = 202 OR "SYMBOL" = 211 OR "SYMBOL" = 301 OR "SYMBOL" = 302 OR "SYMBOL" = 307 OR "SYMBOL" = 415 OR "SYMBOL" = 526 OR "SYMBOL" = 527 OR "SYMBOL" = 528 OR "SYMBOL" = 709' ) forbiddenLineBuff = arcpy.Select_analysis( in_features=ln_buff, out_feature_class=os.path.join(basePath, r"Trash", r"b1"), where_clause= '"SYMBOL" = 201 OR "SYMBOL" = 307 OR "SYMBOL" = 521 OR "SYMBOL" = 524 OR "SYMBOL" = 528 OR "SYMBOL" = 534 OR "SYMBOL" = 709' ) #Hente ut alle passerbare symboler passableArea = arcpy.Select_analysis( in_features=ar, out_feature_class=os.path.join(basePath, r"Trash", r"b2"), where_clause= '"SYMBOL" <> 202 AND "SYMBOL" <> 211 AND "SYMBOL" <> 301 AND "SYMBOL" <> 302 AND "SYMBOL" <> 307 AND "SYMBOL" <> 415 AND "SYMBOL" <> 526 AND "SYMBOL" <> 527 AND "SYMBOL" <> 528 AND "SYMBOL" <> 601 AND "SYMBOL" <> 709' ) passableLineBuff = arcpy.Select_analysis( in_features=ln_buff, out_feature_class=os.path.join(basePath, r"Trash", r"b3"), where_clause= '"SYMBOL" <> 201 AND "SYMBOL" <> 307 AND "SYMBOL" <> 521 AND "SYMBOL" <> 524 AND "SYMBOL" <> 528 AND "SYMBOL" <> 534 AND "SYMBOL" <> 709' ) #Lage skogflater area = arcpy.Update_analysis(in_features=passableArea, update_features=forbiddenArea, out_feature_class=os.path.join( basePath, r"Trash", r"b4")) forest = arcpy.Erase_analysis(in_features=mask, erase_features=area, out_feature_class=os.path.join( basePath, r"Trash", r"b5")) arcpy.AddField_management(in_table=forest, field_name="SYMBOL", field_type="DOUBLE") features = arcpy.UpdateCursor(forest) for feature in features: feature.SYMBOL = 405 features.updateRow(feature) del feature, features #Lage kartet i ArcMap area1 = arcpy.Erase_analysis(in_features=passableArea, erase_features=forbiddenArea, out_feature_class=os.path.join( basePath, r"Trash", r"b6")) area2 = arcpy.Erase_analysis(in_features=area1, erase_features=forbiddenLineBuff, out_feature_class=os.path.join( basePath, r"Trash", r"b7")) passable1 = arcpy.Update_analysis(in_features=area2, update_features=forest, out_feature_class=os.path.join( basePath, r"Trash", r"b8")) mapped = arcpy.Update_analysis(in_features=passable1, update_features=passableLineBuff, out_feature_class=os.path.join( basePath, r"Trash", r"b9")) #Sette kostnad paa alle flater setCost(mapped) print('hey') costRaster = arcpy.FeatureToRaster_conversion( mapped, "COST", os.path.join(basePath, r"Results", r"CostRaster.tif")) #Lage sloperaster #create a TIN of the area tin = arcpy.CreateTin_3d( out_tin=os.path.join(basePath, r"Results", r"TIN"), spatial_reference="#", in_features=os.path.join(basePath, r"Trash", r"hoydedata.shp") + " HOEYDE masspoints") # Replace a layer/table view name with a path to a dataset (which can be a layer file) or create the layer/table view within the script # The following inputs are layers or table views: "hoydeTIN" tinRaster = arcpy.TinRaster_3d(in_tin=os.path.join(basePath, r"Results", r"TIN"), out_raster=os.path.join( basePath, r"Results", "hRaster"), data_type="FLOAT", method="LINEAR", sample_distance="CELLSIZE 1", z_factor="1") # Replace a layer/table view name with a path to a dataset (which can be a layer file) or create the layer/table view within the script # The following inputs are layers or table views: "hraster" slope = arcpy.Slope_3d(in_raster=os.path.join(basePath, r"Results", r"hRaster"), out_raster=os.path.join(basePath, r"Results", r"slope"), output_measurement="DEGREE", z_factor="1") # Reklassifisering av slope reMapRange = RemapRange([[0, 0.5, 100], [0.5, 1, 101], [1, 2, 102], [2, 3, 103], [3, 4, 104], [4, 5, 105], [5, 6, 106], [6, 7, 107], [7, 8, 108], [8, 9, 109], [9, 10, 110], [10, 11, 111], [11, 12, 112], [12, 13, 113], [13, 14, 114], [14, 15, 115], [15, 16, 116], [16, 17, 117], [17, 18, 118], [18, 19, 119], [19, 20, 120], [20, 90, 150]]) slope_reclass = Reclassify(in_raster=os.path.join(basePath, r"Results", r"slope"), reclass_field="VALUE", remap=reMapRange) slope_reclass.save(os.path.join(basePath, r"Results", r"slopeReclass")) # Rasterkalkulator som lager raster som tar hensyn til hoyde i kostnadsrasteret finalCostRaster = Raster( os.path.join(basePath, r"Results", r"CostRaster.tif")) * ( Raster(os.path.join(basePath, r"Results", r"slopeReclass")) / 100) #Regne ut leastcostpath cdr = arcpy.sa.CostDistance(start, finalCostRaster) cdr.save(os.path.join(basePath, r"Results", r"costDistance")) cbr = arcpy.sa.CostBackLink(start, finalCostRaster) cbr.save(os.path.join(basePath, r"Results", r"Costback")) cp = arcpy.sa.CostPath(destination, cdr, cbr, "EACH_CELL") cp.save(os.path.join(basePath, r"Results", r"costpath")) #Gjore om til polygon med litt bredde arcpy.RasterToPolygon_conversion( in_raster=os.path.join(basePath, r"Results", r"costpath"), out_polygon_features=os.path.join(basePath, r"Results", r"cpPoly.shp"), simplify="SIMPLIFY") arcpy.Buffer_analysis(in_features=os.path.join(basePath, r"Results", r"cpPoly.shp"), out_feature_class=os.path.join( basePath, r"Results", r"LCP.shp"), buffer_distance_or_field="2", line_side="FULL", line_end_type="FLAT", dissolve_option="LIST") df = arcpy.mapping.ListDataFrames(mxd, "*")[0] for lyr in arcpy.mapping.ListLayers(mxd, "", df): arcpy.mapping.RemoveLayer(df, lyr) print("Deleted lyr's in mxd") #Legge til i ArcMap templateLayer = arcpy.mapping.Layer( os.path.join(basePath, r"Template", r"colorTemplate.lyr")) df = arcpy.mapping.ListDataFrames(mxd, "*")[0] newlayer = arcpy.mapping.Layer( os.path.join(basePath, r"Results", r"LCP.shp")) newlayer.transparency = 50 """ PROBLEMBARN RETT UNDER """ arcpy.ApplySymbologyFromLayer_management(in_layer=newlayer, in_symbology_layer=templateLayer) # in_symbology_layer = os.path.join(basePath, r"Template", r"colorTemplate.lyr")) """ PROBLEMBARN RETT OVER """ arcpy.mapping.AddLayer(df, newlayer, "BOTTOM") arcpy.MakeRasterLayer_management(in_raster=kart, out_rasterlayer=os.path.join( basePath, r"Results", r"rasterkart")) mapLayer = arcpy.mapping.Layer( os.path.join(basePath, r"Results", r"rasterkart")) arcpy.mapping.AddLayer(df, mapLayer, "BOTTOM") # Lage postsirkler og linje og legge til dette i ArcGIS points = arcpy.CreateFeatureclass_management(out_path=os.path.join( basePath, r"Trash"), out_name="points", geometry_type="POINT") del destination start = getStart(pt) destination = getDestination(pt) features = arcpy.UpdateCursor(start) for feature in features: startX = feature.POINT_X startY = feature.POINT_Y features = arcpy.UpdateCursor(destination) for feature in features: destX = feature.POINT_X destY = feature.POINT_Y cursor = arcpy.da.InsertCursor(points, ("fid", "SHAPE@XY")) cursor.insertRow((1, (startX, startY))) cursor.insertRow((2, (destX, destY))) del destination outerCircle = arcpy.CreateFeatureclass_management(out_path=os.path.join( basePath, r"Trash"), out_name="circles1.shp", geometry_type="POLYGON") innerCircle = arcpy.CreateFeatureclass_management(out_path=os.path.join( basePath, r"Trash"), out_name="circles2.shp", geometry_type="POLYGON") circle = arcpy.CreateFeatureclass_management( out_path=os.path.join(basePath, r"Trash"), out_name="circles.shp", geometry_type="POLYGON", ) arcpy.Buffer_analysis(points, outerCircle, 40) arcpy.Buffer_analysis(points, innerCircle, 35) arcpy.Erase_analysis(outerCircle, innerCircle, circle) symLayer = arcpy.mapping.Layer( os.path.join(basePath, r"Template", r"color2.lyr")) circleLayer = arcpy.mapping.Layer( os.path.join(basePath, r"Trash", r"circles.shp")) arcpy.ApplySymbologyFromLayer_management(in_layer=circleLayer, in_symbology_layer=symLayer) arcpy.mapping.AddLayer(data_frame=df, add_layer=circleLayer, add_position="TOP") # Lage postlinje lines = arcpy.CreateFeatureclass_management(out_path=os.path.join( basePath, r"Trash"), out_name="line.shp", geometry_type="POLYGON") directionX = (destX - startX) / ( math.sqrt(math.pow(destX - startX, 2) + math.pow(destY - startY, 2))) directionY = (destY - startY) / ( math.sqrt(math.pow(destX - startX, 2) + math.pow(destY - startY, 2))) features = [] features.append( arcpy.Polyline( arcpy.Array([ arcpy.Point(startX + 45 * directionX, startY + 45 * directionY), arcpy.Point(destX - 45 * directionX, destY - 45 * directionY) ]))) lineFeat = arcpy.CopyFeatures_management( features, os.path.join(basePath, r"Trash", r"lines.shp")) arcpy.Buffer_analysis(in_features=lineFeat, out_feature_class=lines, buffer_distance_or_field=2.5, line_end_type="FLAT") lineLayer = arcpy.mapping.Layer( os.path.join(basePath, r"Trash", r"line.shp")) arcpy.ApplySymbologyFromLayer_management(in_layer=lineLayer, in_symbology_layer=symLayer) arcpy.mapping.AddLayer(data_frame=df, add_layer=lineLayer, add_position="TOP") mxd.save() #Skrive ut bilde av veivalg B = df.extent.XMax - df.extent.XMin H = df.extent.YMax - df.extent.YMin filename = str(uploaderpk) + "_" + time.strftime( "%d-%m-%Y") + "_" + time.strftime("%H-%M-%S") + ".png" relative_path_string = os.path.join(r"Dump", filename) print("hurr " + settings.PROJECT_PATH) print("durr " + relative_path_string) out_path = os.path.join(settings.PROJECT_PATH, "files", r"Dump", filename) print(out_path) arcpy.mapping.ExportToPNG(map_document=mxd, out_png=out_path, data_frame=df, df_export_width=int(3 * B), df_export_height=int(3 * H), resolution=225) print("Finished making image") #relative_path = os.path.join(r"Dump", "MapLCP.png") img = Image() img.uploader = PathUser.objects.get(pk=uploaderpk) img.bilde = relative_path_string img.save() folder = os.path.join(basePath, r"Trash") for file in os.listdir(folder): filepath = os.path.join(folder, file) try: if os.path.isfile(filepath): print "Removing " + filepath os.remove(filepath) elif os.path.isdir(filepath): print "Removing " + filepath shutil.rmtree(filepath) except Exception as e: print(e) folder = os.path.join(basePath, r"Results") for file in os.listdir(folder): filepath = os.path.join(folder, file) try: if os.path.isfile(filepath): print "Removing " + filepath os.remove(filepath) elif os.path.isdir(filepath): print "Removing " + filepath shutil.rmtree(filepath) except Exception as e: print(e) delete_user_uploads.delay(uploaderpk) end = time.time() print(end - startTime)
polygon = arcpy.Polygon(arcpy.Array(boundaryPoints)) arcpy.CreateFeatureclass_management(arcpy.env.workspace, name + '_Boundary.shp', 'POLYGON', polygon) arcpy.CopyFeatures_management(polygon, name + '_Boundary.shp') arcpy.AddMessage(name + '_Boundary.shp generated.') # Create TIN based on topo data and boundary arcpy.CreateTin_3d(name + '_TIN') arcpy.EditTin_3d( name + '_TIN', [[name + '_Points.shp', 'Z', '<None>', 'Mass_Points', False], [name + '_Boundary.shp', '<None>', '<None>', 'Soft_Clip', False]]) arcpy.AddMessage(name + '_TIN generated.') # Create raster out of TIN arcpy.TinRaster_3d(name + '_TIN', name + '_Raster.tif', 'FLOAT', 'LINEAR', sample_distance='CELLSIZE {}'.format(cellsize), z_factor=1) arcpy.AddMessage(name + '_Raster.tif generated.') # Create hillshade out of raster arcpy.HillShade_3d(name + '_Raster.tif', name + '_Hillshade.tif', azimuth, altitude, z_factor=1) arcpy.AddMessage(name + '_Hillshade.tif generated.')
def inundation_map_builder(cut_line_file, profile, output_raster, output_shapefile): xs_cut_lines = cut_line_file profile = profile output_shapefile = output_shapefile output_raster = output_raster try: if arcpy.CheckExtension("3D") == "Available": arcpy.CheckOutExtension("3D") else: # Raise a custom exception # raise LicenseError if arcpy.CheckExtension("Spatial") == "Available": arcpy.CheckOutExtension("Spatial") else: # Raise a custom exception # raise LicenseError # Local variables: modelbuild = "D:\\LittleCal_Inundations\\TINS\\modelbuildtin" modelbuild11 = "D:\\LittleCal_Inundations\\Rasters\\modelbuild11" cook_thorn = "D:\GIS\cook_thorn" modelbuild13 = "D:\\LittleCal_Inundations\\Rasters\\" + output_raster mdelbuild1int = "D:\\LittleCal_Inundations\\Rasters\\mdelbuild1int" modelbuild1dis_shp = "D:\\LittleCal_Inundations\\Shapefiles\\modelbuild1dis.shp" modelbuild1_shp = "D:\\LittleCal_Inundations\\Shapefiles\\" + output_shapefile mapping_xs = "D:\LittleCal_Inundations\Shapefiles\MappingXS.shp" bound_poly = "D:\\LittleCal_Inundations\\Shapefiles\\BoundingPolygonLeveet.shp" params = mapping_xs + " " + profile + " Soft_Line <None>; " + bound_poly + " <None> " + "Hard_Clip <None>" #params = "XSCutlines2.shp 05FEB2008_2400 Soft_Line <None>; BoundingPolygonLeveet.shp <None> Hard_Clip <None>" coord = "PROJCS['NAD83 / Illinois East (ftUS)',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',984250.0]," + \ "PARAMETER['false_northing',0.0],PARAMETER['central_meridian',-88.33333333333333]," + \ "PARAMETER['scale_factor',0.999975]," + \ "PARAMETER['latitude_of_origin',36.66666666666666]," + \ "UNIT['Foot_US',0.3048006096012192]]" # Replace a layer/table view name with a path to a dataset (which can be a layer file) or create the layer/table view within the script # The following inputs are layers or table views: "Mapping_XS", "XS Cut Lines" arcpy.JoinField_management(in_data=mapping_xs, in_field="ProfileM", join_table=xs_cut_lines, join_field="ProfileM", fields=profile) # Process: Create TIN arcpy.CreateTin_3d(modelbuild, coord, params, "DELAUNAY") # Process: TIN to Raster arcpy.TinRaster_3d(modelbuild, modelbuild11, "FLOAT", "LINEAR", "CELLSIZE 2", "1") # Process: Raster Calculator modelbuild12 = ((Raster(modelbuild11) - Raster(cook_thorn)) * ((Raster(modelbuild11) - Raster(cook_thorn)) > 0)) # Process: Set Null arcpy.gp.SetNull_sa(modelbuild12, modelbuild12, modelbuild13, "VALUE = 0") # Process: Int arcpy.Int_3d(modelbuild13, mdelbuild1int) # Process: Raster to Polygon arcpy.RasterToPolygon_conversion(mdelbuild1int, modelbuild1dis_shp, "SIMPLIFY", "Value") arcpy.RepairGeometry_management(modelbuild1dis_shp) # Process: Dissolve arcpy.Dissolve_management(modelbuild1dis_shp, modelbuild1_shp, "", "", "MULTI_PART", "DISSOLVE_LINES") arcpy.DeleteField_management(in_table=mapping_xs, drop_field=profile) except LicenseError: print("3D or Spatial Analyst license is unavailable") except arcpy.ExecuteError: print(arcpy.GetMessages(2)) finally: arcpy.CheckInExtension("3D") arcpy.CheckInExtension("Spatial")
#checking license availability if arcpy.CheckExtension("3D") == "Available": #Take a license arcpy.CheckOutExtension("3D") #Create a new empty TIN arcpy.CreateTin_3d("tin2") #Edit TIN arcpy.EditTin_3d("tin2", parameters) ## arcpy.EditTin_3d("tin2", inFCs) #Tin to raster data_type = "FLOAT" interp_method = "LINEAR" samp_method = "CELLSIZE 10" factor = 1 arcpy.TinRaster_3d(output_folder + "\\tin2", output_folder + "\\grid", interp_method, samp_method, factor) #release the license arcpy.CheckInExtension("3D") else: print('License not available') #------------------------------------------------------------------------------- # CHECKING LICENSES #------------------------------------------------------------------------------- import arcpy arcpy.env.overwriteOutput = True arcpy.env.workspace = r"C:\ELVLC\DATA\castilla-leon" #output folder output = 'C:\ELVLC\DATA\results'
# -*- coding: utf-8 -*- import arcpy """ 此脚本的优势是能够解决用gispro或arcmap不能对县域大量等高线和高程点数据进行处理的问题 """ # 输入参数 dgx = "I:\\毕节国土空间规划\\分析库\\地形图信息提取.gdb\\等高线_首曲线" gcd = "I:\\毕节国土空间规划\\分析库\\地形图信息提取.gdb\\高程点" # 输出参数 cellsize = "5" # 以米为单位 tin = "F:\\test\\tin" dem = "F:\\test\\dem" arcpy.env.overwriteOutput = True arcpy.AddMessage("begin to create TIN.....") arcpy.CreateTin_3d(out_tin=tin, spatial_reference="", in_features=[[dgx, "Elevation", "Hard_Line", "<None>"], [gcd, "Elevation", "Mass_Points", "<None>"]], constrained_delaunay="DELAUNAY") arcpy.AddMessage("begin to create DEM.....") arcpy.TinRaster_3d(in_tin=tin, out_raster=dem, data_type="FLOAT", method="LINEAR", sample_distance="CELLSIZE " + cellsize, z_factor=1, sample_value=250)
arcpy.AddMessage('Your TIN ' + str(args.OutputTIN) + ' has been successfully created.') #If the user checked the create DEM then create DEM, if user said to delete the TIN then delete TIN if args.OutputDEM: if os.path.exists(args.OutputDEM): arcpy.AddMessage(args.OutputDEM + ' already exists.') arcpy.CheckInExtension('3D') sys.exit() else: arcpy.AddMessage('Creating DEM...') outDEM = args.OutputDEM cellSize = args.CellSize arcpy.TinRaster_3d(args.OutputTIN, args.OutputDEM, 'FLOAT', 'NATURAL_NEIGHBORS', 'CELLSIZE ' + args.CellSize) arcpy.AddMessage('Your DEM ' + args.OutputDEM + ' was successfully created.\n') if args.DeleteTIN: #The folder to contain the TIN automatically changes the users inputs to all lowercase letters, the below makes #the input argument the same and removes the folder shutil.rmtree(os.path.split(args.OutputTIN)[0] + '\\' + os.path.split(args.OutputTIN)[1].lower()) arcpy.AddMessage('The input tin ' + args.OutputTIN + ' was removed.') except: arcpy.CheckInExtension('3D') arcpy.AddMessage(sys.exc_info()[1]) finally: arcpy.CheckInExtension('3D')