Elev_sitemaster2 = "H:\AQUARIUS\Hypothetical\AUCKLAND_NORTH\AUCKLAND_NORTH_rasteradded.shp"
Elev_site3Dmaster = "H:\AQUARIUS\Hypothetical\AUCKLAND_NORTH\AUCKLAND_NORTH_3D.shp"
# Process: Extract Values to Points
arcpy.gp.ExtractValuesToPoints_sa(Elev_sitemaster, AKL_CBD_Raster,
Elev_sitemaster2, "INTERPOLATE",
"VALUE_ONLY")
# Process: Add Field
#arcpy.AddField_management(Elev_sitemaster2, "Elevation", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Process: Calculate Field
arcpy.CalculateField_management(Elev_sitemaster2, "ElevationFINAL",
"[RASTERVALU]+2", "VB", "")
# Process: Feature To 3D By Attribute
arcpy.FeatureTo3DByAttribute_3d(Elev_sitemaster2, Elev_site3Dmaster,
"ElevationFINAL", "")
# Split vector layer on FID - for quick analysis I split the entire file. It also helps me understand immediately if anything is going wrong with the execution.
## arcpy.Split_analysis()
########## ------------------------------------------------------------------------------- ##############
# model 2: building elevation
# Input and output variable definition
Bldg_footprint = "H:\AQUARIUS\Hypothetical\Hypothetical_simple\BLDG_c25b16.shp"
Bldg3D = "H:\AQUARIUS\Hypothetical\Hypothetical_simple\BLDG_c25b16_3D.shp"
# Process: Add Field
arcpy.AddField_management(Bldg_footprint, "Z", "DOUBLE", "", "", "", "",
"NULLABLE", "NON_REQUIRED", "")
for type in layerType:
for feature in featureLists:
if type in feature:
# print feature + " yes"
arcpy.AddMessage(feature + " yes")
lists = []
for floor in range(rangeNum01, rangeNum02 + 1):
floorStr = str(floor)
arcpy.Copy_management(feature, type + "_floor" + floorStr)
arcpy.CalculateField_management(type + "_floor" + floorStr, "floor", floorStr)
for floor_id in range(len(building_floor.floor)):
if building_floor.floor[floor_id] == floor:
buildingFloor_z = building_floor.floor_z[floor_id]
arcpy.CalculateField_management(type + "_floor" + floorStr, "floor_z", buildingFloor_z)
arcpy.CalculateField_management(type + "_floor" + floorStr, "z", buildingFloor_z + zValue)
arcpy.FeatureTo3DByAttribute_3d(type + "_floor" + floorStr, type + "_floor3D" + floorStr, "z")
arcpy.Delete_management(type + "_floor" + floorStr)
arcpy.AddMessage(type + "_floor" + floorStr + "_Part")
lists.append(type + "_floor3D" + floorStr)
# print lists
arcpy.AddMessage(lists)
outName = outPath + "/" + shortName + "_" + str(rangeNum01) + "_" + str(rangeNum02) + "_" + type
arcpy.Merge_management(lists, outName)
for floor in range(rangeNum01, rangeNum02 + 1):
floorStr = str(floor)
arcpy.Delete_management(type + "_floor3D" + floorStr)
# print(type + floorNum + "_floor3D" + " Finished")
arcpy.AddMessage(type + floorNum + "_floor3D" + " Finished")
# Features duplicating and Add z_Value
layerType = ['spraysys', 'autoalarmsys', 'handalarmsys', 'broadcastsys', 'pysys', 'sfsys']
def preparation_for_evaluation(solution):
solution.representation = uls.equalize_and_repair_representation_and_fc(
solution, self.IDW, self.endpoints, 3,
self.restricted_airspace, self.geofence_point_boundary)
solution = uls.check_synchronization(solution)
solution.placeholder_smooth_line = solution.PointFCName + "_ph_sml"
solution.placeholder_repaired_points = solution.PointFCName + "_3d_rep"
solution.placeholder_line_to_points = solution.PointFCName + "_ph_ltp"
solution.placeholder_dense_points = solution.PointFCName + "_ph_dp"
solution.placeholder_interpolated_surface = arcpy.env.workspace + "\\" + solution.PointFCName + "_ph_ints"
solution.placeholder_dense_points_min_height = solution.PointFCName + "_ph_minh"
solution.placeholder_dense_points_interpolated = solution.PointFCName + "_ph_dpi"
solution.placeholder_dense_points_interpolated_3d = solution.PointFCName + "_ph_3d"
uls.pointsToLine(solution.PointFCName, solution.LineFCName)
uls.smoothline(solution.LineFCName,
solution.placeholder_smooth_line, 100,
self.restricted_airspace)
uls.lineToPoints(solution.placeholder_smooth_line,
solution.placeholder_dense_points, 10)
# create field
uls.interpolate_points_to_spline_surface(
solution.PointFCName,
solution.placeholder_interpolated_surface, 20)
# get interpolated height at current cell of IDW (corresponding z in solution.representation)
uls.extractValues_many_Rasters(
solution.placeholder_dense_points,
r" {} grid_z1; {} grid_z2; {} noise; {} int_z;{} grid_z".
format(solution.placeholder_interpolated_surface,
self.noisemap,
solution.placeholder_interpolated_surface, self.IDW,
self.IDW))
arcpy.FeatureTo3DByAttribute_3d(
solution.placeholder_dense_points,
solution.placeholder_dense_points_interpolated_3d, "int_z")
solution.placeholder_representation = uls.point3d_fc_to_np_array(
solution.placeholder_dense_points_interpolated_3d,
additional_fields=["grid_z", "noise"])
solution.placeholder_representation = uls.line_repair(
self.restricted_airspace,
solution.placeholder_smooth_line,
solution.placeholder_dense_points_interpolated_3d,
self.geofence_point_boundary,
placeholder_interpolated_surface=solution.
placeholder_interpolated_surface,
noisemap=self.noisemap,
IDW=self.IDW,
endpoints=self.endpoints,
output_name=solution.placeholder_repaired_points)
solution.placeholder_representation, indices = uls.remove_duplicate_points(
solution.placeholder_representation[:, 1:3],
solution.placeholder_representation)
uls.remove_points_from_pointfc(
solution.placeholder_repaired_points, indices)
solution.placeholder_representation, valid_reorder = uls.reorder_points(
solution.placeholder_repaired_points,
solution.placeholder_representation,
self.endpoints,
searchradius=100)
if valid_reorder is False:
valid_reorder = 1
else:
valid_reorder = 0
return solution, valid_reorder
rast = arcpy.GetParameterAsText(0)
outLoc = arcpy.GetParameterAsText(1)
outName = arcpy.GetParameterAsText(2)
if not '.' in outName:
outName+=".txt"
outPath = os.path.join(outLoc,outName)
outZip = os.path.join(outLoc,outName.split('.')[0]+'.zip')
arcpy.AddMessage("Running Raster to Point...")
point = arcpy.RasterToPoint_conversion(rast, r"in_memory\TEMPPOINT", "VALUE")
arcpy.AddMessage("Point feature created")
arcpy.AddMessage("Converting to 3D by Attribute...")
threed = arcpy.FeatureTo3DByAttribute_3d(point, r"in_memory\TEMPPOIINT3D","grid_code")
arcpy.Delete_management(r"in_memory\TEMPPOINT")
arcpy.AddMessage("3D conversion complete")
arcpy.AddMessage("Creating XYZ...")
xyz = arcpy.FeatureClassZToASCII_3d(threed,outLoc,outName,"XYZ","COMMA","FIXED",2)
arcpy.Delete_management(r"in_memory\TEMPPOINT3D")
arcpy.AddMessage("XYZ created")
arcpy.AddMessage("Adding header...")
addHeader(outPath)
arcpy.AddMessage("Header added")
arcpy.AddMessage("Zipping...")
with zipfile.ZipFile(outZip, 'w') as newzip:
newzip.write(outPath, outName, zipfile.ZIP_DEFLATED)
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]))
def calculate_height(lc_input_features, lc_ws, lc_tin_dir, lc_input_surface,
lc_is_hand, lc_dem, lc_output_features, lc_log_dir,
lc_debug, lc_memory_switch):
try:
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)
had_field = "height_dem"
# if HAND raster
if lc_is_hand:
arcpy.AddMessage(
"Assuming input surface " +
common_lib.get_name_from_feature_class(lc_input_surface) +
" is a HAND raster.")
arcpy.AddMessage(
"First adding height above DEM to " +
common_lib.get_name_from_feature_class(lc_input_features) +
".")
add_minimum_height_above_drainage(lc_ws, bridge_polys, lc_dem,
had_field, lc_memory_switch)
arcpy.AddMessage(
"Now adding height above HAND raster " +
common_lib.get_name_from_feature_class(lc_input_features) +
".")
add_minimum_height_above_HAND(lc_ws, bridge_polys,
lc_input_surface, had_field,
lc_memory_switch)
else:
# if just DEM
arcpy.AddMessage(
"Assuming input surface " +
common_lib.get_name_from_feature_class(lc_input_surface) +
" is a digital elevation model.")
arcpy.AddMessage(
"Adding height above input surface to " +
common_lib.get_name_from_feature_class(lc_input_features) +
".")
add_minimum_height_above_drainage(lc_ws, bridge_polys,
lc_input_surface, had_field,
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
z_unit = common_lib.get_z_unit(bridge_points3D, lc_debug)
if z_unit == "Meters":
expression = "'m'"
else:
expression = "'ft'"
common_lib.delete_add_field(bridge_points3D, esri_unit, "TEXT")
arcpy.CalculateField_management(bridge_points3D, esri_unit,
expression, "PYTHON_9.3")
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]))
inputDEM = arcpy.GetParameterAsText(
5) ##the input DEM for the area in which the CSV points fall
UWI = arcpy.GetParameterAsText(
6) ##the unique well identifier field in the deviation survey CSV
output = arcpy.GetParameterAsText(
7) ##the name for the output (3d line features) of the script
######################################################################################################################################################################
##The following lines of code execute the necessary geoprocessing tools
##Plot the points from the CSV file
arcpy.MakeXYEventLayer_management(inputCSV, xField, yField, "layer", prj)
arcpy.CopyFeatures_management("layer",
"points") ##Copy those features to a new file
##For each point, get the elevation value from the DEM and add it to a field
arcpy.sa.ExtractValuesToPoints("points", inputDEM, "points_elev")
arcpy.AddField_management(
"points_elev", "New_Depth", "DOUBLE"
) ##Add a field ("New_Depth") to hold the values for the actual elevation of each point
arcpy.CalculateField_management(
"points_elev", "New_Depth", '(!RASTERVALU!*3.28084) - !TVD!', "PYTHON"
) ##Calculate that field with the expression as seen in the code. Convert the rastervalu field to feet from meters, and subtract the true vertical depth
##Make the "points_elev" file 3D by the "New_Depth" field
arcpy.FeatureTo3DByAttribute_3d("points_elev", "points_converted", "New_Depth")
##Convert the 3D points created in the tool above to 3D lines
arcpy.PointsToLine_management("points_converted", output, UWI)
#Elev_sitemaster2 = "H:\AQUARIUS\Hypothetical\AUCKLAND_NORTH\AUCKLAND_NORTH_rasteradded.shp"
Elev_site3Dmaster = "H:\AQUARIUS\Hypothetical\AUCKLAND_NORTH\port2D_3D.shp"
# Process: Extract Values to Points
#arcpy.gp.ExtractValuesToPoints_sa(Elev_sitemaster, AKL_CBD_Raster, Elev_sitemaster2, "INTERPOLATE", "VALUE_ONLY")
# Process: Add Field
arcpy.AddField_management(Elev_sitemaster, "Elevation", "DOUBLE", "", "", "",
"", "NULLABLE", "NON_REQUIRED", "")
# Process: Calculate Field
arcpy.CalculateField_management(Elev_sitemaster, "Elevation", "[GRID_CODE]+70",
"VB", "")
# Process: Feature To 3D By Attribute
arcpy.FeatureTo3DByAttribute_3d(Elev_sitemaster, Elev_site3Dmaster,
"Elevation", "")
# Split vector layer on FID - for quick analysis I split the entire file. It also helps me understand immediately if anything is going wrong with the execution.
## arcpy.Split_analysis()
# model 3: Skyline iterator
# Local variables used in the skyline function:
#arcpy.env.workspace = r'H:\AQUARIUS\Hypothetical\Hypothetical_simple\working_hypothetical.gdb\'
#ALL_rasters = arcpy.Raster() ##raster
inSurface = r'H:\AQUARIUS\Hypothetical\AUCKLAND_NORTH\AUCK_RASTER.gdb\AKL_BLDG_raster'
#obstructionFCs = "H:\AQUARIUS\Hypothetical\Hypothetical_simple\BLDG_c25b16_pointfile_3D.shp"
surfRad = "1000 meters"
surfElev = "0 meters"
def closest_approach(station_loc, flight_ln, flight_path):
# rename variables for local use
sound_station_loc = station_loc #
flight_line = flight_ln #
flight_pts = flight_path #
##################################################
# near 3d used to append distance to inputted sound station to data table for each flight track point
#
# copy data table to prevent changes to original file
arcpy.CopyFeatures_management(flight_pts, "in_memory//flight_pts")
# check out the exenstion
arcpy.CheckOutExtension("3D")
# apply the extension
arcpy.Near3D_3d("in_memory//flight_pts",sound_station_loc,location="LOCATION")
# check in the extension
arcpy.CheckInExtension("3D")
###################################################
#########################################################
# append nearest approach of line to sound station to the line shapefile
#
# first, copy features to prevent overwriting
arcpy.CopyFeatures_management(flight_line, "in_memory//flight_line")
# then use near3d
# check out the exenstion
arcpy.CheckOutExtension("3D")
# apply the extension
arcpy.Near3D_3d("in_memory//flight_line",sound_station_loc,location="LOCATION")
########################################################
########################################################
# create point of closest approach
###########################################################
# extract the x and y coordinates from "in_memory//flight_line"
# and use them to create a new point which will be passed to the extract_by_proximity function
xcoordinate = []
with arcpy.da.SearchCursor("in_memory//flight_line", ['NEAR_FROMX']) as cursor:
for row in cursor:
xcoordinate.append(row[0])
ycoordinate = []
with arcpy.da.SearchCursor("in_memory//flight_line", ['NEAR_FROMY']) as cursor:
for row in cursor:
ycoordinate.append(row[0])
zcoordinate = [0]
# create a point object, make it into a geometry, then add it to the shapefile
ptList =[[xcoordinate[0],ycoordinate[0],zcoordinate[0]]]
pt = arcpy.Point()
ptGeoms = []
for p in ptList:
pt.X = p[0]
pt.Y = p[1]
pt.Z = 0
ptGeoms.append(arcpy.PointGeometry(pt))
# export the new point to shp, define the coordinate system to the same as flight line
arcpy.CopyFeatures_management(ptGeoms, "in_memory//closest_pt")
arcpy.DefineProjection_management ("in_memory//closest_pt", "in_memory//flight_pts")
# add an altitude field to closest_pt
arcpy.AddField_management("in_memory//closest_pt","alt", "SHORT")
# convert into a 3d point feature for use by near3d
arcpy.FeatureTo3DByAttribute_3d("in_memory//closest_pt", "in_memory//closest_pt_3d",'alt')
closest_point = "in_memory//closest_pt_3d"
# check in the extension
arcpy.CheckInExtension("3D")
# assign and return output of function
output_data = ["in_memory//flight_pts",closest_point]
return output_data;
rowlist = []
for field in fields:
rowlist.append(row.getValue(field)) ##append the value to the list
allRows.append(rowlist)
##Write the fields and their associated values to the file
csvFile.writerow(fields)
for row in allRows:
csvFile.writerow(row)
############################################################################################################################################################################
##Convert the features to 3D features, Create TINs, and extrude between the TINs to create the block feature
arcpy.FeatureTo3DByAttribute_3d(
topsname1 + "clean", topsname1 + "_ThreeD", "True_Elev"
) ##This converts the tops file processed up until this point and creates 3D features of it using the "True_Elev" as the height field
arcpy.FeatureTo3DByAttribute_3d(
topsname2 + "clean", topsname2 + "_ThreeD", "True_Elev"
) ##The same as above, but for the tops file of the formation directly below the formation the user wants to create a block feature of
tinfc1 = topsname1 + "_ThreeD" ##Creates a variable of the 3D features created above to be used in the Create TIN scriptinput
tinfc2 = topsname2 + "_ThreeD" ##Same as above, but for the tops file of the formation directly below the formation the user wants to create a block feature of
tin1 = arcpy.CreateTin_3d(outFolder + "/" + topsname1, prj, [
[tinfc1, "True_Elev", "masspoints"]
]) ##Creates a TIN from the 3D features, using "True_Elev" as its height field
tin2 = arcpy.CreateTin_3d(
outFolder + "/" + topsname2, prj, [[tinfc2, "True_Elev", "masspoints"]]
) ##Same as above, but for the tops file of the formation directly below the formation the user wants to create a block feature of