def make_rand_road_pts():
"""
makes the 'rd_far_fld.shp' file which is points on roads that are spaced at least 300 ft from
each other and at least 200 ft from any flood points
:return:
"""
road_shapefile = "nor_roads_centerlines.shp"
arcpy.Densify_edit(road_shapefile, densification_method='DISTANCE', distance=30)
road_pts_file = 'rd_pts_all_1.shp'
arcpy.FeatureVerticesToPoints_management(road_shapefile, road_pts_file)
rand_rd_pts_file = 'rand_road.shp'
rand_rd_pts_lyr = 'rand_road_lyr'
arcpy.CreateRandomPoints_management(gis_proj_dir, rand_rd_pts_file, road_pts_file,
number_of_points_or_field=50000,
minimum_allowed_distance='200 Feet')
print "rand_rd_points_file"
fld_pts_file = 'flooded_points.shp'
fld_pts_buf = 'fld_pt_buf.shp'
arcpy.Buffer_analysis(fld_pts_file, fld_pts_buf, buffer_distance_or_field="200 Feet",
dissolve_option='ALL')
print "buffer"
arcpy.MakeFeatureLayer_management(rand_rd_pts_file, rand_rd_pts_lyr)
arcpy.SelectLayerByLocation_management(rand_rd_pts_lyr, overlap_type='WITHIN',
select_features=fld_pts_buf,
invert_spatial_relationship='INVERT')
rd_pts_outside_buf = 'rd_far_fld.shp'
arcpy.CopyFeatures_management(rand_rd_pts_lyr, rd_pts_outside_buf)
arcpy.JoinField_management(rd_pts_outside_buf, in_field='CID', join_table=road_pts_file,
join_field='FID')
print "rd_points_outside_buf"
def Question_2():
"""
Psuedocode for question 2.2:
1. Import system modules
2. Create random points in the features of a constraining feature class
Number of points for each feature determined by the value in the field
specified
3. Set workspace
4. Create fields for random values
5. Calculate random values between 1-100 in the new fields
"""
import arcpy
out_path = ("C:\Users\pps7\Desktop\Lab6\Lab6a_FeatureClass")
arcpy.env.workspace = ("C:\Users\pps7\Desktop\Lab6\Lab6a_FeatureClass")
arcpy.env.overwriteOutput = True
#Spatial_Reference = arcpy.Describe("C:\Users\pps7\Desktop\Lab6\Lab6a_FeatureClass\Schools").SpatialReference
Output_Name = "School_Random_pts"
Concise_FC = "C:\Users\pps7\Desktop\Lab6\Lab6a_FeatureClass\Schools.shp"
Number_of_Points = 100
arcpy.CreateRandomPoints_management(out_path, Output_Name, Concise_FC, "",
100)
def make_p(buffer_erased_final,point_count,outFC,point_layer): #all_points = getlocations(buffer_erased_final,point_count = point_count) outPath, outName = os.path.split(outFC) #minDistance = "600 Meters" minDistance = "" arcpy.CreateRandomPoints_management(outPath, outName, buffer_erased_final, "", point_count, minDistance)
def _create_random_points(area, buffer_val, points, messages):
# Process: Buffer
buffer_name = arcpy.CreateScratchName("temp", data_type="Shapefile", workspace=arcpy.env.scratchFolder)
arcpy.Buffer_analysis(points, buffer_name, buffer_val, "FULL", "ROUND", "ALL", "", "PLANAR")
# Process: Erase
erase_name = arcpy.CreateScratchName("temp", data_type="Shapefile", workspace=arcpy.env.scratchFolder)
arcpy.Erase_analysis(area, buffer_name, erase_name, "")
# Process: Create Random Points
random_name = arcpy.CreateScratchName("temp", data_type="FeatureClass", workspace=arcpy.env.scratchFolder)
num_points = int(arcpy.GetCount_management(points))
arcpy.CreateRandomPoints_management(arcpy.env.scratchFolder, random_name, erase_name, "0 0 250 250", num_points,
"1 Meters", "POINT", "0")
messages.AddMessage(str(arcpy.GetCount_management(random_name)) + " Random points created")
# array = arcpy.da.FeatureClassToNumPyArray(random_name, "SHAPE@XY")
# arcpy.Delete_management(buffer_name)
# arcpy.Delete_management(erase_name)
# arcpy.Delete_management(random_name)
# return array
return random_name
def createRandomPoint(path):
ap.CheckOutExtension("Spatial")
outFolder = path
numPoints = 40
outName = "random_point.shp"
conFC = path+"/out_final.img"
ap.AddMessage("Creating Random Point")
ap.CreateRandomPoints_management(outFolder, outName, "", conFC, numPoints)
ap.AddMessage("Finished creat random point")
def onRectangle(self, rectangle_geometry):
extent = rectangle_geometry
arcpy.env.workspace = r'c:\ArcpyBook\Ch10'
if arcpy.Exists('randompts.shp'):
arcpy.Delete_management('randompts.shp')
randompts = arcpy.CreateRandomPoints_management(arcpy.env.workspace,
'randompts.shp', "",
rectangle_geometry)
arcpy.RefreshActiveView()
return randompts
def test_gpresult_dummy(self):
arcpy.env.workspace = "in_memory"
arcpy.env.overwriteOutput = True
r = arcpy.CreateRandomPoints_management(out_path="in_memory", out_name="Guwu2",
constraining_feature_class="#", constraining_extent="0 0 250 250",
number_of_points_or_field="100", minimum_allowed_distance="0 Unknown",
create_multipoint_output="POINT", multipoint_size="0")
g = dump_gpresult(r)
R = Result(g)
self.assertEqual(r.outputCount, R.outputCount)
self.assertEqual(r.inputCount, R.inputCount)
# The output is the most important thing to ensure equality.
self.assertListEqual([r.getOutput(i) for i in range(r.outputCount)],
[R.getOutput(i) for i in range(r.outputCount)])
def Create_random_points(self):
'''
Creating random points from the range of constraining feature.
:param outpath: The geo-database to output.
:param outname: The output feature name.
:param constrainingfeatureclass: The range of generating random points.
:param numberofpoints: The numbers for creating random points.
:return:
'''
arcpy.AddMessage("Creating random points")
# env.outputCoordinateSystem = arcpy.SpatialReference("Xian 1980 3 Degree GK Zone 43")
arcpy.CreateRandomPoints_management(self.OutputFeaturePath, self.OutputFeatureName, self.InputConstraingFeature,'',self.Numbersofpoints)
# arcpy.CreateFishnet_management(self.OutputFeature,'1397827.035600 4660075.233999999', '1397827.035599999 4660085.233999999 ', 1000,1000, 600, 700, '1694007.492800001 4940949.5798', "LABELS", '#', "POLYGON")
arcpy.AddMessage("Finishing creating random points from %s"%str(self.OutputFeaturePath+'\\'+self.OutputFeatureName))
def rnd_points(rndPntShp, NPoints, whereShp, distTolerance=None):
"""
Create NRandom Points inside some area
and save the result in one file
"""
import os
from gasp.oss import get_filename
distT = "" if not distTolerance else "{} Meters".format(distTolerance)
arcpy.CreateRandomPoints_management(os.path.dirname(rndPntShp),
get_filename(rndPntShp), whereShp, "",
NPoints, distT, "POINT", "0")
return rndPntShp
def assign_pond_locations(self):
"""
This method assigns random locations for each pond that fall within the bounds of
suitable habitat.
:return:
"""
num_points = int(s.DENSITY * self.upland_area) - self.pond_count
logging.info('num points: {}'.format(num_points))
# constraint is the area of all suitable locations for new_ponds
# num_points is the maximum number of new_ponds that should be assigned
arcpy.CreateRandomPoints_management(
out_path=s.TEMP_DIR,
out_name=self._pond_point_file,
constraining_feature_class=self.suitability_points,
number_of_points_or_field=num_points,
minimum_allowed_distance=s.MINIMUM_DISTANCE)
def plot_regression(workspace, explan_var, depend_var, model, sample_num):
arcpy.env.overwriteOutput = True
arcpy.env.workspace = workspace
workspace = arcpy.env.workspace
arcpy.CheckOutExtension("Spatial")
exp_var = explan_var
dep_var = depend_var
input_sample = sample_num
arcpy.CreateRandomPoints_management(workspace, "samplepoints", "", exp_var,
input_sample, "", "POINT")
ExtractValuesToPoints("samplepoints", exp_var, "exp_points" "", "")
ExtractValuesToPoints("samplepoints", dep_var, "dep_points" "", "")
exp_array = arcpy.da.FeatureClassToNumPyArray("exp_points", "RASTERVALU")
dep_array = arcpy.da.FeatureClassToNumPyArray("dep_points", "RASTERVALU")
pyplot.scatter(exp_array, dep_array)
pyplot.show()
return
def GenerateTransects(workspace, Map_Units, field_name, out_name):
"""
Creates random transect locations
:param workspace: the project's unique geodatabase
:param Map_Units: the Map_Units_Dissolve feature class with number of
transects identified in the attribute table
:param field_name: the field in the attribute table with transect
requirements defined
:param out_name: a name to save the output as
:return: the name of the output as a string
"""
arcpy.AddMessage("Generating random transect locations within each map "
"unit")
# Create random points in buffered map units
transects = arcpy.CreateRandomPoints_management(workspace, out_name,
Map_Units,
"#", field_name, 25)
return transects
def plot_regression(workspace, explanatory, dependent, model_coeffs, samples):
#print "starting plotting regression"
arcpy.CheckOutExtension("Spatial")
arcpy.env.workspace = workspace #Get the workspace path
arcpy.env.overwriteOutput = True #setup overwrite protection status
#convert input strings into rasters
#print "converting input data to rasters"
Exp_raster = arcpy.sa.Raster(explanatory)
Dep_raster = arcpy.sa.Raster(dependent)
outGDB = workspace
outName = "RandomPoints"
conFC = Exp_raster
numField = samples
#print "generating random points"
RandomPoints = arcpy.CreateRandomPoints_management(outGDB, outName, "",
conFC, numField)
Exp_rastrer_Extract2Points = arcpy.sa.ExtractValuesToPoints(
RandomPoints, Exp_raster, "Exp_raster_FCPnts")
Dep_rastrer_Extract2Points = arcpy.sa.ExtractValuesToPoints(
RandomPoints, Dep_raster, "Dep_raster_FCPnts")
arcpy.CheckInExtension("Spatial")
Exp_numpy_array = arcpy.da.FeatureClassToNumPyArray(
Exp_rastrer_Extract2Points, "RASTERVALU")
Dep_numpy_array = arcpy.da.FeatureClassToNumPyArray(
Dep_rastrer_Extract2Points, "RASTERVALU")
X = Exp_numpy_array
X_sorted = np.sort(X)
#print X[0][0]
#print X[-1][0]
Y = Dep_numpy_array
plt.scatter(X, Y)
#source: https://www.kite.com/python/answers/how-to-plot-a-polynomial-fit-from-an-array-of-points-using-numpy-and-matplotlib-in-python
x_predict = np.linspace(
X_sorted[0][0], X_sorted[-1][0]) #/samples #not workiing frome kite
#x_predict = np.array(range(35)) #/ this gives me a line 35 units length
#val_range = np.amax(X,axis=1)
#x_predict = np.array(range(val_range)) #/
predict = np.poly1d(model_coeffs)
y_predict = predict(x_predict)
plt.plot(x_predict, y_predict, c='r')
plt.show()
def generate_point(shape_file):
merge = []
for row in arcpy.da.SearchCursor(shape_file, ['FID', 'SampleSize']):
sql = """{0} = {1}""".format('FID', row[0])
out_name = 'FID' + str(row[0])
constrain_feat = arcpy.Select_analysis(in_features=shape_file,
out_feature_class=out_name,
where_clause=sql)
if CheckBox_pointfile == 'false':
arcpy.AddMessage('Creating random points for features...')
out_name += '_testpoints'
arcpy.CreateRandomPoints_management(
out_path=Workspace,
out_name=out_name,
constraining_feature_class=constrain_feat,
number_of_points_or_field=row[1],
minimum_allowed_distance='1 Meter',
create_multipoint_output='POINT')
merge.append(out_name + '.shp')
else:
#select points within the polygon
arcpy.AddMessage('Selecting random points for features...')
in_feat = arcpy.SelectLayerByLocation_management(
in_layer=Point_file,
overlap_type='INTERSECT',
select_features=out_name + '.shp',
selection_type='NEW_SELECTION')
out_name += '_testpoints'
#print(in_feat)
arcpy.SubsetFeatures_ga(in_features=in_feat,
out_training_feature_class=out_name,
size_of_training_dataset=row[1],
subset_size_units='ABSOLUTE_VALUE')
merge.append(out_name + '.shp')
#print(merge)
arcpy.AddMessage('Merging files...')
arcpy.Merge_management(merge, Save_file)
arcpy.AddMessage('Points generated')
def DemNoise(self, inDEM, outDEM, mean, stdev, mask, noise_order):
arcpy.env.overwriteOutput = True
arcpy.env.extent = inDEM
# Process: Create Random Raster
tempPath = tempfile.gettempdir()
print(tempPath)
rMetadata = arcpy.Raster(inDEM)
# Process: Create Random Points
arcpy.CreateRandomPoints_management(tempPath, "randomPoints.shp", None, mask, "1000", "10 Meters", "POINT", "0")
arcpy.CreateRandomRaster_management(tempPath, "noise.tif", "NORMAL {} {}".format(mean, stdev), inDEM, rMetadata.meanCellHeight)
# Process: Extract Values to Points
arcpy.sa.ExtractValuesToPoints(os.path.join(tempPath, "randomPoints.shp"), os.path.join(tempPath, "noise.tif"), os.path.join(tempPath, "PointsInterpolation.shp"), "INTERPOLATE", "VALUE_ONLY")
# Process: Trend
noise = arcpy.sa.Trend(in_point_features=os.path.join(tempPath, "PointsInterpolation.shp"), z_field="RASTERVALU", cell_size=rMetadata.meanCellWidth, order=noise_order, regression_type="LINEAR", out_rms_file=None)
# Process: Raster Calculator
outRaster = (noise + arcpy.sa.Raster(inDEM)) * arcpy.Raster(mask)
# arcpy.Clip_management(outRaster, in_template_dataset=mask, out_raster=outDEM, clipping_geometry="ClippingGeometry", maintain_clipping_extent="MAINTAIN_EXTENT")
outRaster.save(outDEM)
arcpy.Delete_management(os.path.join(tempPath, "PointsInterpolation.shp"))
arcpy.Delete_management(os.path.join(tempPath, "randomPoints.shp"))
# arcpy.Delete_management(noise)
del noise
return outDEM
def randomPoints(interimName, boundary, numPoints, iterVal, pointType):
"""
Function to add random points within a boundary and append to the burglaries shape file.
Note the interim file must be separately deleted before it can be reused.
This is because it may be required again in a later step.
Args:
interimName (str): The name of the interim shapefile to be created to hold the random points.
boundary (str): The name of the boundary shapefile to create the points within.
numPoints (int): The number of points to be created.
iterVal (int): The number of the current iteration to be added to the attribute table for the points created.
pointType (str): The type of point being created (INITIAL, SECONDARY, BACKGROUND) to be added to the attribute table for the points created.
"""
global prevPoint
# Creates the random points
arcpy.CreateRandomPoints_management(path, interimName, boundary, "",
numPoints)
arcpy.AddField_management(interimName, "ITER", "SHORT")
arcpy.AddField_management(interimName, "TYPE", "TEXT")
# Updates the fields in the table
with arcpy.da.UpdateCursor(interimName,
["ITER", "TYPE", "SHAPE@XY"]) as cursor:
for row in cursor:
row[0] = iterVal
row[1] = pointType
if pointType == "INITIAL":
prevPoint = (row[2][0], row[2][1])
cursor.updateRow(row)
# Adds the subsequent points into the burglaries.shp class that will contain all burglaries
arcpy.Append_management(interimName, "burglaries.shp", "NO_TEST")
numGrass = max(10, numGrassFromRatio)
numCover = totalPoints - numGrass
print "%s 1948: Grass - %d (%d), Cover - %d" % (
site, numGrass, numGrassFromRatio, numCover)
## select by class for grass only polygons
cov48lyr = arcpy.MakeFeatureLayer_management(cov48analysisArea, "cov48lyr")
cov48lyr = arcpy.SelectLayerByAttribute_management(
"cov48lyr", "NEW_SELECTION", " Class_name = 'Grass' ")
## create a feature class for grass only
cov48lyr_Grass = arcpy.CopyFeatures_management("cov48lyr",
"cov48lyr_Grass")
## generate random points within grass
cov48_Grass_RandPoints = arcpy.CreateRandomPoints_management(
out_path=env.workspace,
out_name="cov48_Grass_RandPts.shp",
constraining_feature_class=cov48lyr_Grass,
number_of_points_or_field=numGrass,
minimum_allowed_distance="5 meters")
## do the same for cover
cov48lyr = arcpy.SelectLayerByAttribute_management(
"cov48lyr", "NEW_SELECTION", " Class_name = 'Cover' ")
cov48lyr_Cover = arcpy.CopyFeatures_management("cov48lyr",
"cov48lyr_Cover")
cov48_Cover_RandPoints = arcpy.CreateRandomPoints_management(
out_path=env.workspace,
out_name="cov48_Cover_RandPts.shp",
constraining_feature_class=cov48lyr_Cover,
number_of_points_or_field=numCover,
minimum_allowed_distance="5 meters")
def createSegments(contour_at_mean_high_water, contour_at_surge):
# Start a timer
time1 = time.clock()
arcpy.AddMessage("\nSegmentation of the coastline started at "+str(datetime.now()))
# Specify a tolerance distance or minimum length of a seawall
# Users are not yet given control of this
th = 150
# Create random points along the lines (mean high water and the surge of choice)
# The numbers used are just my choice based on iterative observations
random0 = arcpy.CreateRandomPoints_management(out_path= arcpy.env.workspace, \
out_name= "random0", \
constraining_feature_class= contour_at_mean_high_water, \
number_of_points_or_field= long(1600), \
minimum_allowed_distance = "{0} Feet".format(th))
random1 = arcpy.CreateRandomPoints_management(out_path= arcpy.env.workspace, \
out_name= "random1", \
constraining_feature_class= contour_at_surge, \
number_of_points_or_field= long(1600), \
minimum_allowed_distance = "{0} Feet".format(th))
# Perform a proximity analysis with the NEAR tool
arcpy.Near_analysis(random0, random1)
# Give each point a fixed unique ID
# Create the ID field
arcpy.AddField_management (random0, "UniqueID", "SHORT")
arcpy.AddField_management (random1, "UniqueID", "SHORT")
# Add Unique IDs
arcpy.CalculateField_management(random0, "UniqueID", "[FID]")
arcpy.CalculateField_management(random1, "UniqueID", "[FID]")
# Categorize/Separate each feature based on their near feature
# Crate a table view of random0
table0 = arcpy.MakeTableView_management(random0, "random0_table")
#table1 = arcpy.MakeTableView_management(random1, "random1_table")
# Sort the near feature for each points in random0
random0_sorted = arcpy.Sort_management(table0, "random0_sorte.dbf", [["NEAR_FID", "ASCENDING"]])
# Create "long enough" lists for each of the field of interests: ID, NEAR_ID, and NEAR_DIST
# (distance to closest point). I added [99999] here to extend the list length and avoid IndexError
list_fid = [r.getValue("UniqueID") for r in arcpy.SearchCursor(random0_sorted, ["UniqueID"])] +[99999]
list_nearid = [r.getValue("NEAR_FID") for r in arcpy.SearchCursor(random0_sorted, ["NEAR_FID"])]\
+[99999]
list_neardist = [r.getValue("NEAR_DIST") for r in arcpy.SearchCursor(random0_sorted, ["NEAR_DIST"])]\
+[99999]
del r
# Only take points with near feature within the specified threshold. If it's too far, it's not better
# than the others for a segment point
list_fid_filtered = [i for i in list_neardist if i < th]
# Then initiate a list o contain their Unique ID and Near ID
first_unique_id = []
first_near_id = []
# Get NEAR_ID and Unique ID for each of these points
for i in list_fid_filtered:
first_unique_id.append(list_fid[list_neardist.index(i)])
first_near_id.append(list_nearid[list_neardist.index(i)])
# Only take the unique values in case there are duplicates. This shoudn't happen. Just to make sure.
first_unique_id = [i for i in set(first_unique_id)]
first_near_id = [i for i in set(first_near_id)]
# Now create a new feature out of these points
# Frist let's create a Feature Layer
arcpy.MakeFeatureLayer_management("random0.shp", "random0_lyr")
# Let's select all points and export them into a new feature
random0_points = arcpy.SearchCursor(random0, ["UniqueID"])
point0 = random0_points.next()
for point0 in random0_points:
for i in range(len(first_unique_id)):
if point0.getValue("UniqueID") == first_unique_id[i]:
selector0 = arcpy.SelectLayerByAttribute_management(\
"random0_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(first_unique_id[i]))
del point0, random0_points
new_random0 = arcpy.CopyFeatures_management(selector0, "new_random0")
arcpy.Delete_management('random0_lyr')
# Now for the new point feature, remove clusters of points around them and take only the ones
# with minimum NEAR_DIST
# First, get the geometry attributes of the new points
arcpy.AddGeometryAttributes_management(new_random0, "POINT_X_Y_Z_M", "", "", "")
# Create long enough list of the field of interest (same as the previous)
pointx = [r.getValue("POINT_X") for r in arcpy.SearchCursor(new_random0, ["POINT_X"])] +[99999]
pointy = [r.getValue("POINT_Y") for r in arcpy.SearchCursor(new_random0, ["POINT_Y"])] +[99999]
new_list_fid = [r.getValue("UniqueID") for r in arcpy.SearchCursor(new_random0, ["UniqueID"])]\
+[99999]
new_list_nearid = [r.getValue("NEAR_FID") for r in arcpy.SearchCursor(new_random0, ["NEAR_FID"])]\
+[99999]
new_list_neardist = [r.getValue("NEAR_DIST") for r in arcpy.SearchCursor(new_random0, ["NEAR_DIST"])]\
+[99999]
del r
# Initiate a list of every points that has already been compared to the near points
garbage = []
# Also initiate a list for the new Unique ID and NEAR ID
new_unique_ID = []
new_near_ID = []
# Then, check if the points are right next to them. If so, add them to a temporary list
# and find the one with closest near ID (or find minimum of their NEAR_DIST)
for i in range(len(pointx)):
if i+1 < len(pointx):
# If not within the th range
if not calculateDistance(pointx[i], pointy[i], pointx[i+1], pointy[i+1]) < float(th)*1.5:
# Skip if it's in garbage
if new_list_nearid[i] in garbage:
continue
else:
new_unique_ID.append(new_list_fid[i])
new_near_ID.append(new_list_nearid[i])
# If within the range
else:
# Skip if it's in garbage
if new_list_nearid[i] in garbage:
continue
else:
temp_ID = []
temp_NEAR = []
temp_DIST = []
while True:
temp_ID.append(new_list_fid[i])
temp_NEAR.append(new_list_nearid[i])
temp_DIST.append(new_list_neardist[i])
garbage.append(new_list_nearid[i])
i = i+1
# Stop when within the range again. And add the last point within the range
if not calculateDistance(pointx[i], pointy[i], pointx[i+1], pointy[i+1]) < 200:
temp_ID.append(new_list_fid[i])
temp_NEAR.append(new_list_nearid[i])
temp_DIST.append(new_list_neardist[i])
garbage.append(new_list_nearid[i])
# Calculate the minimum and get the Unique ID and Near ID
minD = min(temp_DIST)
new_unique_ID.append(new_list_fid[new_list_neardist.index(minD)])
new_near_ID.append(new_list_nearid[new_list_neardist.index(minD)])
del temp_ID, temp_NEAR, temp_DIST
break
# Now select these final points export them into new feature.
# These are the end points for the segments to be created
# First, make a layer out of all the random points
arcpy.MakeFeatureLayer_management("random0.shp", "random0_lyr")
arcpy.MakeFeatureLayer_management("random1.shp", "random1_lyr")
# Then select and export the end points into feature0 and feature1
# Based on new_unique_ID for random0
random0_points = arcpy.SearchCursor(random0, ["UniqueID"])
point0 = random0_points.next()
for point0 in random0_points:
for i in range(len(new_unique_ID)):
if point0.getValue("UniqueID") == new_unique_ID[i]:
selected0 = arcpy.SelectLayerByAttribute_management(\
"random0_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(new_unique_ID[i]))
feature0 = arcpy.CopyFeatures_management(selected0, "feature0")
# Based on new_near_ID for random1
random1_points = arcpy.SearchCursor(random1, ["UniqueID"])
point1 = random1_points.next()
for point1 in random1_points:
for k in range(len(new_near_ID)):
if point1.getValue("UniqueID") == new_near_ID[k]:
selected1 = arcpy.SelectLayerByAttribute_management(\
"random1_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(new_near_ID[k]))
feature1 = arcpy.CopyFeatures_management(selected1, "feature1")
del point0, point1, random0_points, random1_points
arcpy.Delete_management('random0_lyr')
arcpy.Delete_management('random1_lyr')
# Now for the actual create of the coastal segments
# Which include creation of polygon and splitting the contours as the corresponding points
# STEPS NECESSARY FOR POLYGON CREATION
# Let's first add geometry attributes to these points
arcpy.AddGeometryAttributes_management(feature0, "POINT_X_Y_Z_M", "", "", "")
arcpy.AddGeometryAttributes_management(feature1, "POINT_X_Y_Z_M", "", "", "")
# Let's create lines that connects points from feature0 to feature1
# Initiate a POLYLINE feature class for these lines
arcpy.CreateFeatureclass_management (arcpy.env.workspace, "connector_lines.shp", "POLYLINE")
# Then for each of the points in feature0, get the correspondingin feature1
# And create a line for each of the two points
with arcpy.da.SearchCursor(feature0, ["NEAR_FID", "POINT_X", "POINT_Y"]) as features0:
for feat0 in features0:
with arcpy.da.SearchCursor(feature1, ["UniqueID", "POINT_X", "POINT_Y"]) as features1:
x=0
for feat1 in features1:
x = x+1
theseTwoPoints = []
if feat0[0] == feat1[0]:
# Get coordinates
X0, Y0 = feat0[1], feat0[2]
X1, Y1 = feat1[1], feat1[2]
# Append coordinates
theseTwoPoints.append(arcpy.PointGeometry(arcpy.Point(X0, Y0)))
theseTwoPoints.append(arcpy.PointGeometry(arcpy.Point(X1, Y1)))
# Create line from the coordinates
subline = arcpy.PointsToLine_management(theseTwoPoints, "subline"+str(x)+".shp")
# Append all lines into one feature
lines = arcpy.Append_management(["subline"+str(x)+".shp"], "connector_lines.shp")
# Then delete subline as it's now unnecessary
arcpy.Delete_management(subline)
continue
del feat0, feat1, features0, features1
# Now that the connectors are created, let's split the segments
# Before splitting contours into segments, let's integrate the points and the segments
# Just in case, there are misalignment
arcpy.Integrate_management([contour_at_mean_high_water, feature0])
arcpy.Integrate_management([contour_at_surge, feature1])
segments0 = arcpy.SplitLineAtPoint_management(contour_at_mean_high_water, feature0, "segments0.shp", "10 Feet")
segments1 = arcpy.SplitLineAtPoint_management(contour_at_surge, feature1, "segments1.shp", "10 Feet")
# And let's give fixed unique ID for each segment
arcpy.CalculateField_management(segments0, "Id", "[FID]")
arcpy.CalculateField_management(segments1, "Id", "[FID]")
# Now with the split segments and connector lines, let's make segment polygon of the segments
almost_segment_polygons = arcpy.FeatureToPolygon_management([segments0, segments1, lines],\
"almost_segment_polygons.shp")
# Adding unique ID to the segment polygons
arcpy.CalculateField_management(almost_segment_polygons, "Id", "[FID]")
# The Feature to Polygon process also created polygons that are surrounded by polygons
# These are because these areas are surrounded by flooded areas at surge.
# They are above the surge and technically safe. So, let's remove them.
arcpy.MakeFeatureLayer_management(almost_segment_polygons, 'almost_segment_polygons_lyr')
arcpy.MakeFeatureLayer_management(segments0, 'segments0_lyr')
# Only the polygons within the mean_high_water segments are at risk
arcpy.SelectLayerByLocation_management('almost_segment_polygons_lyr', 'INTERSECT', 'segments0_lyr')
final_without_length = arcpy.CopyFeatures_management('almost_segment_polygons_lyr', 'final.shp')
arcpy.Delete_management('segments0_lyr')
arcpy.Delete_management('almost_segment_polygons_lyr')
# For the new polygons, let's add the corresponding seawall length
# Let's add Length field to both first
arcpy.AddField_management(final_without_length, "Length", "SHORT")
arcpy.AddField_management(segments0, "Length", "SHORT")
# Calculation of the length
with arcpy.da.UpdateCursor(segments0, ["SHAPE@LENGTH", "Length"]) as segments_0:
for segment_0 in segments_0:
length = segment_0[0]
segment_0[1] = length
segments_0.updateRow(segment_0)
del segment_0, segments_0
# With spatial join, let's add these results to the segment polygons
final = spatialJoin(final_without_length, segments0, "Length", "Length", "max", "joined_segment.shp")
# Delete the created but now unnecessary files
arcpy.Delete_management(random0)
arcpy.Delete_management(random1)
# Stop the timer
time2 = time.clock()
arcpy.AddMessage("Seawall segments and regions successfully created. It took "\
+str(time2-time1)+" seconds")
return final
citrus_only = arcpy.MakeRasterLayer_management(out_raster,
merged_raster_name + "_O")
citrus_only1 = citrus_only.getOutput(0)
arcpy.mapping.AddLayer(df, citrus_only1, "AUTO_ARRANGE")
# Create 40 random polygons on citrus polygon layer
# dissolve IR_3
arcpy.Dissolve_management(citrus, path + r"\citrus_dissolved")
# create random points
outName = "random_points"
conFC = path + r"\citrus_dissolved.shp"
numPoints = 40
arcpy.CreateRandomPoints_management(path, outName, conFC, "", numPoints,
"100 Meters", "", "")
# draw a circle around points using buffer tool
arcpy.Buffer_analysis(path + r"\random_points.shp", path + r"\random_circles",
"20 Meters")
# draw polygons around the circles
arcpy.FeatureEnvelopeToPolygon_management(path + r"\random_circles.shp",
path + r"\random_polygons")
# add random polygons layer to map document
# create a new layer
randomPoly = arcpy.mapping.Layer(path + r"\random_polygons.shp")
# add layers to the map
#Change date to current date date = "2July2018" import arcpy from arcpy import env #Set a workspace workspace = r"C:\GIS_Work\Cphd_Locations\Locations.gdb" env.workspace = workspace env.overwriteOutput = True #1)Generate Random Point in the feature of Overton Park out_path = workspace out_name = "randomPts_" + date con_feat = "C:\GIS_Work\Overton_Park_Features.gdb\Forestboundary_PCS" #Will automatically be generated as the same projection as Overton Park. arcpy.CreateRandomPoints_management(out_path, out_name, con_feat, "", 30) print "Random points were successfully generated" #2) CHANGE PROJECTION TO WGS 1984 OR STEP 4 WON'T WORK in_data = out_name out_data = in_data + "_Project" spat_ref = arcpy.SpatialReference(4326) trans_meth = "NAD_1983_NSRS2007_To_WGS_1984_1" print "Projection successfully changed" arcpy.Project_management(in_data, out_data, spat_ref, trans_meth) #3)Add XY coordinates to table. in_feat = out_data
def execute(self, parameters, messages):
"""
Create random points tool
Create a set of random points constrained to a specific area, maintaining a minimum maximum distance to a
set of points and remaining in areas with full information
:param parameters: parameters object with all the parameters from the python-tool. It contains:
output: Name of the file where the points will be stored
n_points: number of random points to be created
constrain_area: Original constraining area used as baseline for further constraints
rasters: Information rasters that will be used to restrict to areas with full information
buffer_points: The random points will maintain a minimal/maximal distance to these points
buffer_distance: Distance away buffer points
min_distance: Minimal distance along created points
select_inside: Boolean to create the points inside the area (True) or outside the area (False)
:param messages: messages object to print in the console, must implement AddMessage
:return: None
"""
global MESSAGES
MESSAGES = messages
# Print parameters for debugging purposes
print_parameters(parameters)
parameter_dic = {par.name: par for par in parameters}
output = parameter_dic["output_points"].valueAsText.strip("'")
n_points = parameter_dic["number_points"].value
constrain_area = parameter_dic["constraining_area"].valueAsText.strip("'")
rasters = parameter_dic["constraining_rasters"].valueAsText
buffer_points = parameter_dic["buffer_points"].valueAsText
buffer_distance = parameter_dic["buffer_distance"].valueAsText
min_distance = parameter_dic["minimum_distance"].valueAsText
select_inside = parameter_dic["select_inside"].value
# Split the path of the output file in file and database, necesarry for
out_ws, out_f = os.path.split(output)
scratch_files = []
try:
# constrain area to avoid modifications to the original
constrain_scratch = arcpy.CreateScratchName(
"const_sct.shp", workspace=arcpy.env.scratchWorkspace)
arcpy.CopyFeatures_management(
arcpy.Describe(constrain_area).catalogPath, constrain_scratch)
scratch_files.append(constrain_scratch)
_verbose_print(
"Scratch file created (constrain): {}".format(constrain_scratch))
# Constrain to the points only if they exist, otherwise is not constrained
if buffer_points is None or buffer_distance is None:
_verbose_print("Exclude from points omitted")
points_scratch = constrain_scratch
else:
points_scratch = _constrain_from_points(constrain_scratch,
buffer_points,
buffer_distance,
select_inside)
scratch_files.append(points_scratch)
# Constrain to the information raster only if is specified, otherwise do not constrain
if rasters is None:
_verbose_print("Exclude from rasters omitted")
rasters_scratch = points_scratch
else:
rasters_scratch = _constrain_from_raster(points_scratch, rasters)
scratch_files.append(rasters_scratch)
# Dissolve the polygon into a single object to make the selection
dissolve_scratch = arcpy.CreateScratchName(
"diss_sct.shp", workspace=arcpy.env.scratchWorkspace)
arcpy.Dissolve_management(in_features=rasters_scratch,
out_feature_class=dissolve_scratch,
multi_part="MULTI_PART")
scratch_files.append(dissolve_scratch)
# Select the random points
# TODO: Sometimes, random points fall right in the border of the rasters and therefore they show null information, an erosion needs to be added to avoid this
result = arcpy.CreateRandomPoints_management(
out_ws,
out_f,
dissolve_scratch,
number_of_points_or_field=n_points,
minimum_allowed_distance=min_distance)
arcpy.DefineProjection_management(
result,
arcpy.Describe(constrain_area).spatialReference)
MESSAGES.AddMessage("Random points saved in {}".format(result))
except:
raise
finally:
# Delete intermediate files
for s_file in scratch_files:
arcpy.Delete_management(s_file)
_verbose_print("Scratch file deleted: {}".format(s_file))
return
# raster convert to polygon and simplify
arcpy.RasterToPolygon_conversion(r, shpfile, 'SIMPLIFY', 'VALUE')
arcpy.Dissolve_management(shpfile, shpfile_sv, 'GRIDCODE', '#', 'MULTI_PART',
'DISSOLVE_LINES')
# rm water (IGBP == 0)
with arcpy.da.UpdateCursor(shpfile_sv, "GRIDCODE") as cursor:
for row in cursor:
if row[0] == 0.0:
# print row
cursor.deleteRow()
arcpy.RefreshActiveView()
# sample representative points
arcpy.CreateRandomPoints_management(indir, file_st, shpfile_sv, '0 0 250 250',
number, '4 Kilometers', 'POINT', '0')
# https://pro.arcgis.com/zh-cn/pro-app/help/data/geodatabases/overview/arcgis-field-data-types.htm
arcpy.AddField_management(file_st, "site", "SHORT", 5)
arcpy.AddField_management(file_st, "IGBPcode", "SHORT", 2)
# add fields site and IGBPcode (CID + 1)
codeblock = (r'rec = 0 \n' + 'def autoIncrement(): \n' + ' global rec \n' +
' pStart = 1 \n' + ' pInterval = 1 \n' +
' if (rec == 0): \n' + ' rec = pStart \n' +
' else: \n' + ' rec += pInterval \n' +
' return rec \n')
arcpy.CalculateField_management(file_st, 'site', 'autoIncrement()',
'PYTHON_9.3', codeblock)
arcpy.CalculateField_management(file_st, 'IGBPcode', '[CID]+1', 'VB', '#')
exportrastab(predznpop, out_table=os.path.join(predgdb, 'predznpop10000_tab'))
exportrastab(predcupop, out_table=os.path.join(predgdb, 'predcupop10000_tab'))
exportrastab(predznexcessdipop, out_table=os.path.join(predgdb, 'predcudiratio10000_tab'))
exportrastab(predcuexcessdipop, out_table=os.path.join(predgdb, 'predzndiratio10000_tab'))
if not all(arcpy.Exists(os.path.join(predgdb, t)) for t in
['EJWApixelpop10000subhighway_tab', 'EJWApixeldipop10000subhighway_tab',
'predznpop10000highway_tab', 'predcupop10000highway_tab',
'predcudiratio10000highway_tab', 'predzndiratio10000highway_tab']):
exportrastab(ExtractByMask(Raster(EJWApixelpopras_sub), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'EJWApixelpop10000subhighway_tab'))
exportrastab(ExtractByMask(Raster(EJWApixeldipopras_sub), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'EJWApixeldipop10000subhighway_tab'))
exportrastab(ExtractByMask(Raster(predznpop), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'predznpop10000highway_tab'))
exportrastab(ExtractByMask(Raster(predcupop), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'predcupop10000highway_tab'))
exportrastab(ExtractByMask(Raster(predznexcessdipop), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'predcudiratio10000highway_tab'))
exportrastab(ExtractByMask(Raster(predcuexcessdipop), Raster(hpms_ps_uhighbufras)),
out_table=os.path.join(predgdb, 'predzndiratio10000highway_tab'))
#Create random sample to extract values for EJWA, predz, predcu, and highway masks
if not arcpy.Exists(samplepoints):
arcpy.CreateRandomPoints_management(predgdb, os.path.split(samplepoints)[1],
constraining_extent=arcpy.Describe(EJWApixeldipopras_sub).extent,
number_of_points_or_field=1000000,
minimum_allowed_distance=5)
ExtractMultiValuesToPoints(samplepoints, [EJWApixeldipopras_sub, predzn36land, predcu19land, hpms_ps_uhighbufras],
bilinear_interpolate_values='NONE')
for j in range(n_rsc - 2):
n_pts_set[j] = int((n_pts - n_mkts) * (float(n_pts_set[j]) / randint_sum))
n_pts_last = n_pts_last - n_pts_set[j]
n_pts_set[-1] = n_pts_last
print(n_pts_set)
##########################################################################
# generate points
##########################################################################
n_mkts_set = [n_mkts]
n_set = n_mkts_set + n_pts_set
print(n_set)
for i in range(len(n_set)):
points_shp = random_pts + str(i)
arcpy.CreateRandomPoints_management(path, points_shp, boundary, "",
str(n_set[i]), "0 Feet", "POINT", "0")
arcpy.CalculateField_management(path + points_shp + '.shp', "CID", str(i),
"PYTHON_9.3")
##########################################################################
# Process: Create Thiessen Polygons based on layers of resouce points (except markets)
##########################################################################
start2 = time.time()
for i in range(1, n_rsc):
points_shp = random_pts + str(i)
voronoi_shp = path + resouce_vor + str(i) + ".shp"
arcpy.CreateThiessenPolygons_analysis(path + points_shp + ".shp",
voronoi_shp, "ONLY_FID")
inFeatures.append(voronoi_shp)
end2 = time.time() - start2
print end2
#Select random number of activities
activities = np.random.randint(min_activities, max_activities)
print "Number of activities:", activities
#Adjust numbers for saving activity file
if len(str(count)) == 1:
number = "00" + str(count)
elif len(str(count)) == 2:
number = "0" + str(count)
elif len(str(count)) == 3:
number = str(count)
#Select random coordinates for activities
arcpy.CreateRandomPoints_management(save, "AC_" + str(number) + ".shp",
study_area, "", activities,
"100 Meters")
#Access random coordinates file
random_coord = os.path.join(save, "AC_" + str(number) + ".shp")
#Add field for Name
if not FieldExist(random_coord, "NAME"):
arcpy.AddField_management(random_coord, "NAME", "TEXT")
#Set counter activity names
ac_number = 0
#Calculate field values activity names
with arcpy.da.UpdateCursor(random_coord, "NAME") as cursor:
for row in cursor:
def SplitLinksAnalysis(inStreetfile, Outfile):
"""This function first removes all freeways and ramps, then splits all roadway
segments to less than 530 feet to prepare the street link and nodes file."""
global start_time
global workspace
# Remove Highways and Ramps
try:
whereclause1 = '''NOT "CLASS" = 'H' AND NOT "CLASS" = 'RAMP' ''' # Note Centerline file did not have HWY
arcpy.AddMessage(
"Create All Streets Network: Remove Highways and Ramps")
arcpy.AddMessage("Where Clause: " + whereclause1)
allstreetlyr = arcpy.MakeFeatureLayer_management(
inStreetfile, "allstreetlyr", whereclause1)
# Cleanup incase thier is any hanging files...
if arcpy.Exists("SplitLine"):
arcpy.Delete_management("SplitLine")
# Split Lines until all roadway segments are less than 530 feet.
count = 1
i = 0
RndptD = 250 # Used to split segments, halved every iteration to adjust random point splits.
SptLn_start_time = time.time()
arcpy.AddMessage("Start Split Line Process at: %s minutes ---" %
(round((time.time() - start_time) / 60, 1)))
while count > 0:
i += 1
# Get Count of Features Greater than 530 feet
arcpy.AddMessage(str(i) + " : Split segments >= 530 feet")
whereclause2 = "shape_length >= 530"
if not arcpy.Exists("SplitLine"):
street2_lyr = arcpy.MakeFeatureLayer_management(
allstreetlyr, "street2_lyr", whereclause2)
allstreetlyr2 = allstreetlyr
RndPtsSplt = str(RndptD) + " Feet"
Cntresult = arcpy.GetCount_management(street2_lyr)
count = int(Cntresult.getOutput(0))
arcpy.AddMessage("records to split:" + str(count))
if count < 1:
break
# Find Endpoints to remove slivers
Ends1_lyr = arcpy.FeatureVerticesToPoints_management(
allstreetlyr, "Ends1_lyr", "BOTH_ENDS")
buffer = "50 Feet"
Int4_buf_lyr = arcpy.Buffer_analysis(Ends1_lyr, "Int4_buf_lyr",
buffer)
# Split Lines at Random points based on "RndptsD", should splits 99% of points to required length.
Rndptsft = arcpy.CreateRandomPoints_management(
workspace, "Rndptsft", street2_lyr, "", 10000, RndPtsSplt)
Rndptsft2_lyr = arcpy.MakeFeatureLayer_management(
Rndptsft, "Rndptsft2_lyr")
SplitptsLayer = arcpy.SelectLayerByLocation_management(
in_layer=Rndptsft2_lyr,
overlap_type="INTERSECT",
select_features=Int4_buf_lyr,
search_distance=".001 Feet",
selection_type="NEW_SELECTION",
invert_spatial_relationship="INVERT")
else:
street2_lyr = arcpy.MakeFeatureLayer_management(
SplitLine, "street2_lyr" + str(i), whereclause2)
allstreetlyr2 = arcpy.CopyFeatures_management(
SplitLine, "in_memory/SplitLine" + str(i))
arcpy.AddMessage("Check for any remaining long segments")
Cntresult = arcpy.GetCount_management(street2_lyr)
count = int(Cntresult.getOutput(0))
arcpy.AddMessage("records to split:" + str(count))
if count < 1:
break
# Split Remaining Long Lines at Midpoints points to avoid slivers.
SplitptsLayer = arcpy.FeatureVerticesToPoints_management(
street2_lyr, "MidptsSplt", "MID")
# Split Line
ArcpySptLn_start_time = time.time()
arcpy.AddMessage(
" Start Splitting Lines Process at: %s minutes ---" %
(round((time.time() - start_time) / 60, 1)))
SplitLine = arcpy.SplitLineAtPoint_management(
allstreetlyr2, SplitptsLayer, "SplitLine", "1 Feet")
arcpy.AddMessage(
" Complete Splitting Lines Processing Time: %s minutes ---"
% (round((time.time() - ArcpySptLn_start_time) / 60, 1)))
arcpy.AddMessage(
str(i) +
" :Split Line Process Complete %s minutes ---" %
(round((time.time() - start_time) / 60, 1)))
arcpy.AddMessage("Finish Process Iteration: " + str(i))
arcpy.AddMessage("------------------------------")
arcpy.AddMessage("Complete Split Line Process at: %s minutes ---" %
(round((time.time() - start_time) / 60, 1)))
# Copy Final Feature Layers
arcpy.AddMessage("Creating Outputs")
# arcpy.CopyFeatures_management(Int3_lyr,outStreet + "_Ints")
arcpy.CopyFeatures_management(SplitLine, Outfile)
arcpy.AddMessage("Total Process Time: %s minutes ---" % (round(
(time.time() - SptLn_start_time) / 60, 1)))
arcpy.AddMessage("----------------------------------------------")
# Cleanup
arcpy.Delete_management(street2_lyr)
arcpy.Delete_management(Int4_buf_lyr)
arcpy.Delete_management(Rndptsft)
arcpy.Delete_management(Rndptsft2_lyr)
for x in range(i):
try:
ItsSplitLine = "in_memory/SplitLine" + str(x)
arcpy.Delete_management(ItsSplitLine)
except:
pass
except arcpy.ExecuteError:
arcpy.AddMessage(arcpy.GetMessages(2))
except Exception as e:
arcpy.AddMessage(e.args[0])
# If an error occurred, print line number and error message
tb = sys.exc_info()[2]
arcpy.AddMessage("An error occured on line %i" % tb.tb_lineno)
arcpy.AddMessage(str(e))
arcpy.AddWarning(
"Check feature class has CLASS field and H and RAMP values")
print("--- %s minutes ---" % (round(
(time.time() - start_time) / 60, 1)))
# Import system modules
import arcpy, os, sys
import arcpy.mapping
from arcpy import env
# Set workspace
arcpy.env.workspace = workspace
arcpy.env.overwriteOutput = True
# Random perturbation
arcpy.SpatialJoin_analysis(
"areas", "o_points", "areas_new", "JOIN_ONE_TO_MANY", "KEEP_ALL",
"RORI RORI true true false 4 Long 0 0 ,First,#,areas,RORI,-1,-1;origX origX true true false 4 Float 0 0 ,First,#,o_points,origX,-1,-1;origY origY true true false 4 Float 0 0 ,First,#,o_points,origY,-1,-1",
"CONTAINS", "#", "#")
arcpy.CreateRandomPoints_management(workspace, "m_rand_points", "areas_new",
"areas_new", "Join_Count", "", "POINT", "")
arcpy.JoinField_management("m_rand_points", "CID", "areas_new", "OBJECTID",
"origX;origY")
arcpy.DeleteField_management("m_rand_points", "CID")
arcpy.AddXY_management("m_rand_points")
arcpy.AddField_management("m_rand_points", "m_randomX", "FLOAT", "#", "#", "#",
"#", "NULLABLE", "NON_REQUIRED", "#")
arcpy.AddField_management("m_rand_points", "m_randomY", "FLOAT", "#", "#", "#",
"#", "NULLABLE", "NON_REQUIRED", "#")
arcpy.CalculateField_management("m_rand_points", "m_randomX", "[POINT_X]",
"VB", "#")
arcpy.CalculateField_management("m_rand_points", "m_randomY", "[POINT_Y]",
"VB", "#")
arcpy.DeleteField_management("m_rand_points", "POINT_X;POINT_Y")
# Finish Process
#Name: RandomPointsRandomValues.py
#Purpose: create random points with random values
# Import system modules
import arcpy, os, random
from arcpy import env
# Create random points in the features of a constraining feature class
# Number of points for each feature determined by the value in the field specified
outGDB = "C:/data/county.gdb"
outName = "randpeople"
conFC = "C:/data/county.gdb/blocks"
numField = "POP2000"
arcpy.CreateRandomPoints_management(outGDB, outName, conFC, "", numField)
# set workspace
env.workspace = "C:/data/county.gdb"
# Create fields for random values
fieldInt = "fieldInt"
fieldFlt = "fieldFlt"
arcpy.AddField_management(outName, fieldInt, "LONG") # add long integer field
arcpy.AddField_management(outName, fieldFlt, "FLOAT") # add float field
# Calculate random values between 1-100 in the new fields
arcpy.CalculateField_management(outName, fieldInt, "random.randint(1,100)",
"PYTHON", "import random")
arcpy.CalculateField_management(outName, fieldFlt, "random.uniform(1,100)",
"PYTHON", "import random")
#Step 2
#Step Two: Copy Features in SDE to new FC
print("\nCopying features class to: \n {0}...".format(FileGDB))
FCInput = "GIO.Building_A"
FCName = "Building_A_Copy"
FCSave = str(FileGDB) + "/" + str(FCName)
buildingFC = arcpy.CopyFeatures_management(FCInput, FCSave)
#Step Three: Generate Random Points for the DSM and DEM
print("\nGenerating Random Points on: \n {0} for the DSM".format(buildingFC))
RandomPointsDSM = "PointsDSM"
DistanceApart1 = "1 FEET"
DSMPoints = arcpy.CreateRandomPoints_management(FileGDB, RandomPointsDSM,
buildingFC, "", 200,
DistanceApart1, "MULTIPOINT")
print("\nRandom points generated for DSM...")
print("\nGenerating Random Points on: \n {0} for the DEM".format(buildingFC))
RandomPointsDEM = "PointsDEM"
DistanceApart2 = "1 FEET"
DEMPoints = arcpy.CreateRandomPoints_management(FileGDB, RandomPointsDEM,
buildingFC, "", 200,
DistanceApart2, "MULTIPOINT")
print("\nRandom points generated for DEM...")
#Step 4: Adding Surface Information to both Point Feature Classes
print("\nAdding Surface information to DSM points...")
PointsDSM = DSMPoints
RemapRange([[-1000, 0.49, 0], [0.5, 1000, 1]]),
"NODATA")
ONESANDZEROS.save(os.path.join(env.workspace, naming + "Shaded_vs_Unshaded"))
#convert segmented polygons to layer
seg = arcpy.MakeFeatureLayer_management(segmented_AC, "seg.lyr")
cell_size = float(
arcpy.GetRasterProperties_management(VEG_HEIGHT, 'CELLSIZEX').getOutput(0))
#Get Statistics for each segement USING ONES AND ZEROS TO GET TOTAL CELLS SHADED
zonalraster = ZonalStatistics(seg, "OBJECTID", ONESANDZEROS, "SUM", "DATA")
zonalraster.save(os.path.join(env.workspace, naming + "_zonalraster"))
###put centroids in segmented polys
centroids = arcpy.CreateRandomPoints_management(
in_mem, naming + "centroids" + str(randint(0, 99)), seg, "#", 15)
#extract value to centroids
ExtractValuesToPoints(centroids, zonalraster, centroidswithvalues, "NONE",
"VALUE_ONLY")
#add necessary feilds
arcpy.AddField_management(seg, "PERCENT_SHADED", "FLOAT")
arcpy.AddField_management(seg, "SHADED_CELL_COUNT", "FLOAT")
#put point values into corresponding polygons
search_fields = ["OID@", "RASTERVALU", "CID"]
update_fields = ["OID@", "SHAPE@AREA", "PERCENT_SHADED", "SHADED_CELL_COUNT"]
modelist = []
