def linetoCut(outPoint):
bearingFeature = os.path.join(
scratch, 'bearingFeature.shp') #r"in_memory/bearingFeature"#
arcpy.BearingDistanceToLine_management(outPoint[:-4] + ".dbf",
r"in_memory/tB", 'POINT_X',
"POINT_Y", 'BearingD', 'FEET',
'Angle', 'DEGREES', 'GEODESIC', "",
srGCS83)
arcpy.BearingDistanceToLine_management(outPoint[:-4] + ".dbf",
r"in_memory/tBB", 'POINT_X',
"POINT_Y", 'BearingD', 'FEET',
'Angle1', 'DEGREES', 'GEODESIC', "",
srGCS83)
arcpy.Merge_management(["in_memory/tB", "in_memory/tBB"], bearingFeature)
rows = arcpy.da.SearchCursor(bearingFeature, ['Shape@'])
for row in rows:
BearingLine.append([[row[0].firstPoint.X, row[0].firstPoint.Y],
[row[0].lastPoint.X, row[0].lastPoint.Y]])
del rows
if OrderType.lower() == 'point':
temp1 = r"in_memory/bearingFeature" #os.path.join(scratch,'bearingFeature.shp')#
arcpy.Dissolve_management(bearingFeature,
temp1,
dissolve_field="Angle;Angle1")
bearingFeature = temp1
arcpy.MakeFeatureLayer_management(bearingFeature, 'bearingFeature')
com = tuple(
itertools.combinations(
[r[0] for r in arcpy.da.SearchCursor(bearingFeature, ["OID@"])],
2))
comlist = []
for i in range(len(com)):
id1 = com[i][0]
id2 = com[i][1]
arcpy.SelectLayerByAttribute_management(
'bearingFeature', "NEW_SELECTION",
'"FID" =%s OR "FID" = %s ' % (id1, id2))
temp = os.path.join("in_memory", 'com' + str(i))
arcpy.Dissolve_management('bearingFeature', temp)
comlist.append(temp)
arcpy.Merge_management(comlist, "in_memory/cut")
lines = {}
with arcpy.da.SearchCursor("in_memory/cut", ["SHAPE@", "OID@"]) as lcursor:
for line in lcursor:
if (line[0].firstPoint.X, line[0].firstPoint.Y,
line[0].lastPoint.X,
line[0].lastPoint.Y) not in lines.keys():
lines[(line[0].firstPoint.X, line[0].firstPoint.Y,
line[0].lastPoint.X, line[0].lastPoint.Y)] = (line[0],
line[1])
del lcursor
arcpy.CopyFeatures_management("in_memory/cut",
os.path.join(scratch, "cutline.shp"))
return lines.values()
def makeRadials(self, numRadials):
''' make geodesic radials from number of radials '''
segmentAngle = 360.0 / float(numRadials)
segmentAngleList = []
a = 0.0
while a < 360.0:
segmentAngleList.append(a)
a += segmentAngle
fields = {
'x': 'DOUBLE',
'y': 'DOUBLE',
'Bearing': 'DOUBLE',
'Range': 'DOUBLE'
}
tab = self._makeTempTable("radTable", fields)
cursor = arcpy.da.InsertCursor(tab, ['x', 'y', 'Bearing', 'Range'])
for i in self.center:
pt = i.firstPoint
for r in segmentAngleList:
cursor.insertRow([pt.X, pt.Y, r, self.ringMax])
del cursor
self.deleteme.append(tab)
outRadialFeatures = os.path.join("in_memory", "outRadials")
arcpy.BearingDistanceToLine_management(tab, outRadialFeatures, 'x',
'y', 'Range',
self.distanceUnits, 'Bearing',
"DEGREES", "GEODESIC", "#",
self.sr)
self.deleteme.append(outRadialFeatures)
self.radialFeatures = outRadialFeatures
return outRadialFeatures
def calculatePerpendicularAngles(inputFeatureClass, outputFCLines, angleField,
maxDistance, fieldID):
#tempPoints = "in_memory\\TempPoints" #C:\\GIS\\StreamNetworkConfinementOutputGeodatabase01.gdb
fcAngleLines0 = "in_memory\\Angle0"
fcAngleLines180 = "in_memory\\Angle180"
fcAngleMerge = "in_memory\\AngleMerge"
#resetData(tempPoints)
#arcpy.CopyFeatures_management(inputFeatureClass,tempPoints)
arcpy.AddField_management(inputFeatureClass, "Angle0", "Double")
arcpy.AddField_management(inputFeatureClass, "Angle180", "Double")
arcpy.AddField_management(inputFeatureClass, "AngleDistance", "Double")
arcpy.CalculateField_management(inputFeatureClass, "Angle0",
"( !" + angleField + "! - 90 )*(-1)",
"PYTHON")
arcpy.CalculateField_management(inputFeatureClass, "Angle180",
"!Angle0!+180", "PYTHON")
arcpy.CalculateField_management(inputFeatureClass, "AngleDistance",
str(maxDistance / 2), "PYTHON")
#arcpy.AddXY_management(inputFeatureClass)
resetData(fcAngleLines0)
resetData(fcAngleLines180)
arcpy.BearingDistanceToLine_management(inputFeatureClass, fcAngleLines0,
"POINT_X", "POINT_Y",
"AngleDistance", "#", "Angle0",
"DEGREES", "GEODESIC", fieldID)
arcpy.BearingDistanceToLine_management(inputFeatureClass, fcAngleLines180,
"POINT_X", "POINT_Y",
"AngleDistance", "#", "Angle180",
"DEGREES", "GEODESIC", fieldID)
resetData(fcAngleMerge)
arcpy.Merge_management([fcAngleLines180, fcAngleLines0], fcAngleMerge)
resetData(outputFCLines)
arcpy.UnsplitLine_management(fcAngleMerge, outputFCLines, fieldID)
return
def strikeToLine(self, xytable):
""" Convert strike tabular data to shapefile polyline
Input: xytable
xytable: tabular data contain x and y coordinates
Output: outdir
outdir: directory or folder of output shapefile polyline
"""
# Set coordinate system of future shapefile
prj, outdir = self.prj, self.outdir
# Import csv file already calculated by dirToAz method
pt = "/Input/DirazCalculated.csv" # don't use pandas DataFrame as an input data
# A dataframe that contain the caracteristic of different output shp file
ft = pd.DataFrame(
[['ln', 'lnc', 'dipln', 'merge'], ['stk', 'stk', 'dipaz', 'merge'],
['St1.shp', 'St2.shp', 'DipAzimut.shp', 'St_Strike.shp']],
columns=['Measure1', 'Measure2', 'DipAz', 'Strike'])
for i in range(len(ft) + 1):
if 'merge' == ft.iloc[0, i]:
arcpy.Merge_management(
[outdir + ft.iloc[2, 0], outdir + ft.iloc[2, 1]],
outdir + ft.iloc[2, 3])
arcpy.Dissolve_management(outdir + ft.iloc[2, 3],
outdir + "Direction.shp", "id", "",
"MULTI_PART", "DISSOLVE_LINES")
print '--- Your tabular data is converted in shapefile successfully !---'
else:
arcpy.BearingDistanceToLine_management(
in_table=pt,
out_featureclass=outdir + ft.iloc[2, i],
x_field='x',
y_field='y',
distance_field=ft.iloc[0, i],
distance_units="METERS",
bearing_field=ft.iloc[1, i],
bearing_units="DEGREES",
line_type="GEODESIC",
id_field='id',
spatial_reference=prj)
return
row[8] = Azline2(row[4])
#Set distance to the length of the transect divided by 2, the transect scripts creates the length on either side of the streamline
#So if the input width it 30 ft, it will create 30 ft on each side (=60 ft), we only want the total to be 30 ft
row[10] = row[9] / 2
iter2 = iter2 + 1
arcpy.SetProgressorPosition()
updateRows.updateRow(row)
del updateRows
del row
#Generate Azline1 and Azline2
Azline1 = "Azline1"
Azline2 = "Azline2"
#Hard-coded as FEET below, I don't think I need to change that.
arcpy.BearingDistanceToLine_management(LineSplit, Azline1, "X_mid",
"Y_mid", "Distance", "FEET",
"AziLine_1", "DEGREES", "GEODESIC",
"LineID", spatial_reference)
arcpy.BearingDistanceToLine_management(LineSplit, Azline2, "X_mid",
"Y_mid", "Distance", "FEET",
"AziLine_2", "DEGREES", "GEODESIC",
"LineID", spatial_reference)
#Create Azline and append Azline1 and Azline2
Azline = "Azline"
arcpy.CreateFeatureclass_management(General_GDB, "Azline", "POLYLINE", "",
"", "", spatial_reference)
arcpy.AddField_management(Azline, "LineID", "DOUBLE")
arcpy.Append_management([Azline1, Azline2], Azline, "NO_TEST")
#Dissolve Azline
Azline_Dissolve = "Azline_Dissolve"
def tableToLineOfBearing(inputTable, inputCoordinateFormat, inputXField,
inputYField, inputBearingUnits, inputBearingField,
inputDistanceUnits, inputDistanceField,
outputLineFeatures, inputLineType,
inputSpatialReference):
'''
Tool method for converting a table of starting points, bearings, and distances
to line features.
inputTable - input table, each row will be a separate line feature in output
inputCoordinateFormat - coordinate notation format of input vertices
inputXField - field in inputTable for vertex x-coordinate, or full coordinate
inputYField - field in inputTable for vertex y-coordinate, or None
inputBearingUnits -
inputBearingField -
inputDistanceUnits -
inputDistanceField -
outputLineFeatures - polyline feature class to create
inputLineType -
inputSpatialReference - spatial reference of input coordinates
returns polyline feature class
inputCoordinateFormat must be one of the following:
* DD_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash.
* DD_2: Longitude and latitude values are in two separate fields.
* DDM_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash.
* DDM_2: Longitude and latitude values are in two separate fields.
* DMS_1: Both longitude and latitude values are in a single field. Two values are separated by a space, a comma, or a slash.
* DMS_2: Longitude and latitude values are in two separate fields.
* GARS: Global Area Reference System. Based on latitude and longitude, it divides and subdivides the world into cells.
* GEOREF: World Geographic Reference System. A grid-based system that divides the world into 15-degree quadrangles and then subdivides into smaller quadrangles.
* UTM_ZONES: The letter N or S after the UTM zone number designates only North or South hemisphere.
* UTM_BANDS: The letter after the UTM zone number designates one of the 20 latitude bands. N or S does not designate a hemisphere.
* USNG: United States National Grid. Almost exactly the same as MGRS but uses North American Datum 1983 (NAD83) as its datum.
* MGRS: Military Grid Reference System. Follows the UTM coordinates and divides the world into 6-degree longitude and 20 latitude bands, but MGRS then further subdivides the grid zones into smaller 100,000-meter grids. These 100,000-meter grids are then divided into 10,000-meter, 1,000-meter, 100-meter, 10-meter, and 1-meter grids.
inputBearingUnits must be one of the following:
* DEGREES
* MILS
* RADS
* GRAD
inputDistanceUnits must be one of the following:
* METERS
* KILOMETERS
* MILES
* NAUTICAL_MILES
* FEET
* US_SURVEY_FEET
inputLineType must be one of the following:
* GEODESIC:
* GREAT_CIRCLE:
* RHUMB_LINE:
* NORMAL_SECTION:
'''
try:
env.overwriteOutput = True
deleteme = []
joinFieldName = "JoinID"
scratch = '%scratchGDB%'
if env.scratchWorkspace:
scratch = env.scratchWorkspace
inputSpatialReference = _checkSpatialRef(inputSpatialReference)
copyRows = os.path.join(scratch, "copyRows")
arcpy.CopyRows_management(inputTable, copyRows)
originalTableFieldNames = _tableFieldNames(inputTable,
joinExcludeFields)
addUniqueRowID(copyRows, joinFieldName)
arcpy.AddMessage("Formatting start point...")
copyCCN = os.path.join(scratch, "copyCCN")
arcpy.ConvertCoordinateNotation_management(copyRows, copyCCN,
inputXField, inputYField,
inputCoordinateFormat,
"DD_NUMERIC", joinFieldName,
inputSpatialReference)
arcpy.AddMessage("Creating lines as {0}...".format(inputLineType))
arcpy.BearingDistanceToLine_management(
copyCCN, outputLineFeatures, "DDLon", "DDLat", inputDistanceField,
inputDistanceUnits, inputBearingField, inputBearingUnits,
inputLineType, joinFieldName, inputSpatialReference)
#Join original table fields to output
arcpy.AddMessage(
"Joining fields from input table to output line features...")
arcpy.JoinField_management(outputLineFeatures, joinFieldName, copyRows,
joinFieldName, originalTableFieldNames)
arcpy.DeleteField_management(outputLineFeatures, [joinFieldName])
return outputLineFeatures
except arcpy.ExecuteError:
# Get the tool error messages
msgs = arcpy.GetMessages()
arcpy.AddError(msgs)
print(msgs)
except:
# Get the traceback object
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
# Concatenate information together concerning the error into a message string
pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(
sys.exc_info()[1])
msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages() + "\n"
# Return python error messages for use in script tool or Python Window
arcpy.AddError(pymsg)
arcpy.AddError(msgs)
# Print Python error messages for use in Python / Python Window
print(pymsg + "\n")
print(msgs)
finally:
if len(deleteme) > 0:
# cleanup intermediate datasets
if debug == True:
arcpy.AddMessage("Removing intermediate datasets...")
for i in deleteme:
if debug == True: arcpy.AddMessage("Removing: " + str(i))
arcpy.Delete_management(i)
if debug == True: arcpy.AddMessage("Done")
addRow.RingID = y
addRows.insertRow(addRow)
y += 1
del addRow
del addRows
del getRow
del getRows
results = arcpy.GetCount_management(tempRadialTable)
# build ellipses
arcpy.AddMessage("Constructing " + str(results) +
" radial features ...")
arcpy.BearingDistanceToLine_management(tempRadialTable, outputRadials,
"POINT_X", "POINT_Y", "Range",
distanceUnits, "Azimuth",
bearingUnits, "RHUMB_LINE",
"RingID", inputCentersSR)
# Join fields
tempRadialTableOIDFieldName = arcpy.Describe(
tempRadialTable).OIDFieldName
radialOIDFieldName = arcpy.Describe(outputRadials).OIDFieldName
#arcpy.JoinField_management(outputRadials,radialOIDFieldName,tempRadialTable,tempRadialTableOIDFieldName,["Azimuth","Range","RingID"])
else:
arcpy.AddMessage("Zero radials to build ...")
# set output
arcpy.SetParameter(3, outputRings)
if buildRadials == True:
# Set local variables
## Were using a Concatenate to make the path of the folderpath
## This combines the filename and filepath so the OS can read it.
line_1 = os.path.join(str(TempDir), "line_1.shp")
line_2 = os.path.join(str(TempDir), "line_2.shp")
line_3 = os.path.join(str(TempDir), "line_3.shp")
lines = os.path.join(str(TempDir), "ObservationLines.shp")
startpoint_1 = os.path.join(str(TempDir), "ObsPoint1")
startpoint_2 = os.path.join(str(TempDir), "ObsPoint2")
startpoint_3 = os.path.join(str(TempDir), "ObsPoint3")
startpoints = os.path.join(str(TempDir), "ObservationPoints.shp")
# Create lines and points
## Process: bearings and distances to lines
arcpy.BearingDistanceToLine_management(filepath, line_1, "lon1", "lat1",
"dist", "METERS", "az1", "DEGREES",
"GEODESIC", "", wgs)
arcpy.BearingDistanceToLine_management(filepath, line_2, "lon2", "lat2",
"dist", "METERS", "az2", "DEGREES",
"GEODESIC", "", wgs)
arcpy.BearingDistanceToLine_management(filepath, line_3, "lon3", "lat3",
"dist", "METERS", "az3", "DEGREES",
"GEODESIC", "", wgs)
## Make XY Event Layers: creating of start points in WGS84 using inputed data
arcpy.MakeXYEventLayer_management(filepath, "lon1", "lat1", startpoint_1, wgs,
"")
arcpy.MakeXYEventLayer_management(filepath, "lon2", "lat2", startpoint_2, wgs,
"")
arcpy.MakeXYEventLayer_management(filepath, "lon3", "lat3", startpoint_3, wgs,
"")
def generate_transects(workspacePath, lineFL, splitType,
distanceBetweenTransects, transectWidth, widthUnit,
outputFC):
import arcpy
import math
#Set environments
arcpy.env.overwriteOutput = True
arcpy.env.XYResolution = "0.00001 Meters"
arcpy.env.XYTolerance = "0.0001 Meters"
# Set local variables
arcpy.env.workspace = workspacePath
Lines = lineFL
SplitType = splitType
DistanceSplit = float(distanceBetweenTransects)
TransecLength = transectWidth
TransecLength_Unit = widthUnit
OutputTransect = outputFC
# Def splitline module
###START SPLIT LINE CODE IN A SAME DISTANCE### Source: http://nodedangles.wordpress.com/2011/05/01/quick-dirty-arcpy-batch-splitting-polylines-to-a-specific-length/
def splitline(inFC, FCName, alongDist):
OutDir = arcpy.env.workspace
outFCName = FCName
outFC = OutDir + "/" + outFCName
def distPoint(p1, p2):
calc1 = p1.X - p2.X
calc2 = p1.Y - p2.Y
return math.sqrt((calc1**2) + (calc2**2))
def midpoint(prevpoint, nextpoint, targetDist, totalDist):
newX = prevpoint.X + ((nextpoint.X - prevpoint.X) *
(targetDist / totalDist))
newY = prevpoint.Y + ((nextpoint.Y - prevpoint.Y) *
(targetDist / totalDist))
return arcpy.Point(newX, newY)
def splitShape(feat, splitDist):
# Count the number of points in the current multipart feature
#
partcount = feat.partCount
partnum = 0
# Enter while loop for each part in the feature (if a singlepart feature
# this will occur only once)
#
lineArray = arcpy.Array()
while partnum < partcount:
# Print the part number
#
#print "Part " + str(partnum) + ":"
part = feat.getPart(partnum)
#print part.count
totalDist = 0
pnt = part.next()
pntcount = 0
prevpoint = None
shapelist = []
# Enter while loop for each vertex
#
while pnt:
if not (prevpoint is None):
thisDist = distPoint(prevpoint, pnt)
maxAdditionalDist = splitDist - totalDist
#print thisDist, totalDist, maxAdditionalDist
if (totalDist + thisDist) > splitDist:
while (totalDist + thisDist) > splitDist:
maxAdditionalDist = splitDist - totalDist
#print thisDist, totalDist, maxAdditionalDist
newpoint = midpoint(prevpoint, pnt,
maxAdditionalDist,
thisDist)
lineArray.add(newpoint)
shapelist.append(lineArray)
lineArray = arcpy.Array()
lineArray.add(newpoint)
prevpoint = newpoint
thisDist = distPoint(prevpoint, pnt)
totalDist = 0
lineArray.add(pnt)
totalDist += thisDist
else:
totalDist += thisDist
lineArray.add(pnt)
#shapelist.append(lineArray)
else:
lineArray.add(pnt)
totalDist = 0
prevpoint = pnt
pntcount += 1
pnt = part.next()
# If pnt is null, either the part is finished or there is an
# interior ring
#
if not pnt:
pnt = part.next()
#if pnt:
#print "Interior Ring:"
partnum += 1
if (lineArray.count > 1):
shapelist.append(lineArray)
return shapelist
if arcpy.Exists(outFC):
arcpy.Delete_management(outFC)
arcpy.Copy_management(inFC, outFC)
#origDesc = arcpy.Describe(inFC)
#sR = origDesc.spatialReference
#revDesc = arcpy.Describe(outFC)
#revDesc.ShapeFieldName
deleterows = arcpy.UpdateCursor(outFC)
for iDRow in deleterows:
deleterows.deleteRow(iDRow)
try:
del iDRow
del deleterows
except:
pass
inputRows = arcpy.SearchCursor(inFC)
outputRows = arcpy.InsertCursor(outFC)
fields = arcpy.ListFields(inFC)
numRecords = int(arcpy.GetCount_management(inFC).getOutput(0))
OnePercentThreshold = numRecords // 100
#printit(numRecords)
iCounter = 0
iCounter2 = 0
for iInRow in inputRows:
inGeom = iInRow.shape
iCounter += 1
iCounter2 += 1
if (iCounter2 > (OnePercentThreshold + 0)):
#printit("Processing Record "+str(iCounter) + " of "+ str(numRecords))
iCounter2 = 0
if (inGeom.length > alongDist):
shapeList = splitShape(iInRow.shape, alongDist)
for itmp in shapeList:
newRow = outputRows.newRow()
for ifield in fields:
if (ifield.editable):
newRow.setValue(ifield.name,
iInRow.getValue(ifield.name))
newRow.shape = itmp
outputRows.insertRow(newRow)
else:
outputRows.insertRow(iInRow)
del inputRows
del outputRows
#printit("Done!")
###END SPLIT LINE CODE IN A SAME DISTANCE###
# Create "General" file geodatabase
WorkFolder = arcpy.env.workspace
General_GDB = WorkFolder + "\General.gdb"
arcpy.CreateFileGDB_management(WorkFolder, "General", "CURRENT")
arcpy.env.workspace = General_GDB
#Unsplit Line
LineDissolve = "LineDissolve"
arcpy.Dissolve_management(Lines, LineDissolve, "", "", "SINGLE_PART")
LineSplit = "LineSplit"
#Split Line
if SplitType == "Split at approximate distance":
splitline(LineDissolve, LineSplit, DistanceSplit)
else:
arcpy.SplitLine_management(LineDissolve, LineSplit)
#Add fields to LineSplit
FieldsNames = [
"LineID", "Direction", "Azimuth", "X_mid", "Y_mid", "AziLine_1",
"AziLine_2", "Distance"
]
for fn in FieldsNames:
arcpy.AddField_management(LineSplit, fn, "DOUBLE")
#Calculate Fields
CodeBlock_Direction = """def GetAzimuthPolyline(shape):
radian = math.atan((shape.lastpoint.x - shape.firstpoint.x)/(shape.lastpoint.y - shape.firstpoint.y))
degrees = radian * 180 / math.pi
return degrees"""
CodeBlock_Azimuth = """def Azimuth(direction):
if direction < 0:
azimuth = direction + 360
return azimuth
else:
return direction"""
CodeBlock_NULLS = """def findNulls(fieldValue):
if fieldValue is None:
return 0
elif fieldValue is not None:
return fieldValue"""
arcpy.CalculateField_management(LineSplit, "LineID", "!OBJECTID!",
"PYTHON_9.3")
arcpy.CalculateField_management(LineSplit, "Direction",
"GetAzimuthPolyline(!Shape!)",
"PYTHON_9.3", CodeBlock_Direction)
arcpy.CalculateField_management(LineSplit, "Direction",
"findNulls(!Direction!)", "PYTHON_9.3",
CodeBlock_NULLS)
arcpy.CalculateField_management(LineSplit, "Azimuth",
"Azimuth(!Direction!)", "PYTHON_9.3",
CodeBlock_Azimuth)
arcpy.CalculateField_management(
LineSplit, "X_mid", "!Shape!.positionAlongLine(0.5,True).firstPoint.X",
"PYTHON_9.3")
arcpy.CalculateField_management(
LineSplit, "Y_mid", "!Shape!.positionAlongLine(0.5,True).firstPoint.Y",
"PYTHON_9.3")
CodeBlock_AziLine1 = """def Azline1(azimuth):
az1 = azimuth + 90
if az1 > 360:
az1-=360
return az1
else:
return az1"""
CodeBlock_AziLine2 = """def Azline2(azimuth):
az2 = azimuth - 90
if az2 < 0:
az2+=360
return az2
else:
return az2"""
arcpy.CalculateField_management(LineSplit, "AziLine_1",
"Azline1(!Azimuth!)", "PYTHON_9.3",
CodeBlock_AziLine1)
arcpy.CalculateField_management(LineSplit, "AziLine_2",
"Azline2(!Azimuth!)", "PYTHON_9.3",
CodeBlock_AziLine2)
arcpy.CalculateField_management(LineSplit, "Distance", TransecLength,
"PYTHON_9.3")
#Generate Azline1 and Azline2
spatial_reference = arcpy.Describe(Lines).spatialReference
Azline1 = "Azline1"
Azline2 = "Azline2"
arcpy.BearingDistanceToLine_management(LineSplit, Azline1, "X_mid",
"Y_mid", "Distance",
TransecLength_Unit, "AziLine_1",
"DEGREES", "GEODESIC", "LineID",
spatial_reference)
arcpy.BearingDistanceToLine_management(LineSplit, Azline2, "X_mid",
"Y_mid", "Distance",
TransecLength_Unit, "AziLine_2",
"DEGREES", "GEODESIC", "LineID",
spatial_reference)
#Create Azline and append Azline1 and Azline2
Azline = "Azline"
arcpy.CreateFeatureclass_management(arcpy.env.workspace, "Azline",
"POLYLINE", "", "", "",
spatial_reference)
arcpy.AddField_management(Azline, "LineID", "DOUBLE")
arcpy.Append_management([Azline1, Azline2], Azline, "NO_TEST")
#Dissolve Azline
Azline_Dissolve = "Azline_Dissolve"
arcpy.Dissolve_management(Azline, Azline_Dissolve, "LineID", "",
"SINGLE_PART")
#Add Fields to Azline_Dissolve
FieldsNames2 = ["x_start", "y_start", "x_end", "y_end"]
for fn2 in FieldsNames2:
arcpy.AddField_management(Azline_Dissolve, fn2, "DOUBLE")
#Calculate Azline_Dissolve fields
arcpy.CalculateField_management(
Azline_Dissolve, "x_start",
"!Shape!.positionAlongLine(0,True).firstPoint.X", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "y_start",
"!Shape!.positionAlongLine(0,True).firstPoint.Y", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "x_end",
"!Shape!.positionAlongLine(1,True).firstPoint.X", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "y_end",
"!Shape!.positionAlongLine(1,True).firstPoint.Y", "PYTHON_9.3")
#Generate output file
arcpy.XYToLine_management(Azline_Dissolve, OutputTransect, "x_start",
"y_start", "x_end", "y_end", "", "",
spatial_reference)
#Delete General.gdb
arcpy.Delete_management(General_GDB)
def XSLayout(output_workspace, flowline, split_type, transect_spacing,
transect_width, transect_width_unit):
# Set environment variables
arcpy.env.overwriteOutput = True
arcpy.env.XYResolution = "0.00001 Meters"
arcpy.env.XYTolerance = "0.0001 Meters"
# Create "General" file geodatabase
WorkFolder = os.path.dirname(output_workspace)
General_GDB = WorkFolder + "\General.gdb"
arcpy.CreateFileGDB_management(WorkFolder, "General", "CURRENT")
arcpy.env.workspace = General_GDB
# List parameter values
arcpy.AddMessage("Output Workspace: {}".format(output_workspace))
arcpy.AddMessage("Workfolder: {}".format(WorkFolder))
arcpy.AddMessage("Flowline: "
"{}".format(arcpy.Describe(flowline).baseName))
arcpy.AddMessage("Split Type: {}".format(split_type))
arcpy.AddMessage("XS Spacing: {}".format(transect_spacing))
arcpy.AddMessage("XS Width: {}".format(transect_width))
arcpy.AddMessage("XS Width Units: {}".format(transect_width_unit))
#Unsplit Line
LineDissolve = "LineDissolve"
arcpy.Dissolve_management(flowline, LineDissolve, "", "", "SINGLE_PART")
LineSplit = "LineSplit"
#Split Line
if split_type == "Split at approximate distance":
splitline(LineDissolve, LineSplit, transect_spacing)
else:
arcpy.SplitLine_management(LineDissolve, LineSplit)
#Add fields to LineSplit
FieldsNames = [
"LineID", "Direction", "Azimuth", "X_mid", "Y_mid", "AziLine_1",
"AziLine_2", "Distance"
]
for fn in FieldsNames:
arcpy.AddField_management(LineSplit, fn, "DOUBLE")
#Calculate Fields
CodeBlock_Direction = """def GetAzimuthPolyline(shape):
radian = math.atan((shape.lastpoint.x - shape.firstpoint.x)/(shape.lastpoint.y - shape.firstpoint.y))
degrees = radian * 180 / math.pi
return degrees"""
CodeBlock_Azimuth = """def Azimuth(direction):
if direction < 0:
azimuth = direction + 360
return azimuth
else:
return direction"""
CodeBlock_NULLS = """def findNulls(fieldValue):
if fieldValue is None:
return 0
elif fieldValue is not None:
return fieldValue"""
arcpy.CalculateField_management(LineSplit, "LineID", "!OBJECTID!",
"PYTHON_9.3")
arcpy.CalculateField_management(LineSplit, "Direction",
"GetAzimuthPolyline(!Shape!)",
"PYTHON_9.3", CodeBlock_Direction)
arcpy.CalculateField_management(LineSplit, "Direction",
"findNulls(!Direction!)", "PYTHON_9.3",
CodeBlock_NULLS)
arcpy.CalculateField_management(LineSplit, "Azimuth",
"Azimuth(!Direction!)", "PYTHON_9.3",
CodeBlock_Azimuth)
arcpy.CalculateField_management(
LineSplit, "X_mid", "!Shape!.positionAlongLine(0.5,True).firstPoint.X",
"PYTHON_9.3")
arcpy.CalculateField_management(
LineSplit, "Y_mid", "!Shape!.positionAlongLine(0.5,True).firstPoint.Y",
"PYTHON_9.3")
CodeBlock_AziLine1 = """def Azline1(azimuth):
az1 = azimuth + 90
if az1 > 360:
az1-=360
return az1
else:
return az1"""
CodeBlock_AziLine2 = """def Azline2(azimuth):
az2 = azimuth - 90
if az2 < 0:
az2+=360
return az2
else:
return az2"""
arcpy.CalculateField_management(LineSplit, "AziLine_1",
"Azline1(!Azimuth!)", "PYTHON_9.3",
CodeBlock_AziLine1)
arcpy.CalculateField_management(LineSplit, "AziLine_2",
"Azline2(!Azimuth!)", "PYTHON_9.3",
CodeBlock_AziLine2)
arcpy.CalculateField_management(LineSplit, "Distance", transect_width,
"PYTHON_9.3")
#Generate Azline1 and Azline2
spatial_reference = arcpy.Describe(flowline).spatialReference
Azline1 = "Azline1"
Azline2 = "Azline2"
arcpy.BearingDistanceToLine_management(LineSplit, Azline1, "X_mid",
"Y_mid", "Distance",
transect_width_unit, "AziLine_1",
"DEGREES", "GEODESIC", "LineID",
spatial_reference)
arcpy.BearingDistanceToLine_management(LineSplit, Azline2, "X_mid",
"Y_mid", "Distance",
transect_width_unit, "AziLine_2",
"DEGREES", "GEODESIC", "LineID",
spatial_reference)
#Create Azline and append Azline1 and Azline2
Azline = "Azline"
arcpy.CreateFeatureclass_management(arcpy.env.workspace, "Azline",
"POLYLINE", "", "", "",
spatial_reference)
arcpy.AddField_management(Azline, "LineID", "DOUBLE")
arcpy.Append_management([Azline1, Azline2], Azline, "NO_TEST")
#Dissolve Azline
Azline_Dissolve = "Azline_Dissolve"
arcpy.Dissolve_management(Azline, Azline_Dissolve, "LineID", "",
"SINGLE_PART")
#Add Fields to Azline_Dissolve
FieldsNames2 = ["x_start", "y_start", "x_end", "y_end"]
for fn2 in FieldsNames2:
arcpy.AddField_management(Azline_Dissolve, fn2, "DOUBLE")
#Calculate Azline_Dissolve fields
arcpy.CalculateField_management(
Azline_Dissolve, "x_start",
"!Shape!.positionAlongLine(0,True).firstPoint.X", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "y_start",
"!Shape!.positionAlongLine(0,True).firstPoint.Y", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "x_end",
"!Shape!.positionAlongLine(1,True).firstPoint.X", "PYTHON_9.3")
arcpy.CalculateField_management(
Azline_Dissolve, "y_end",
"!Shape!.positionAlongLine(1,True).firstPoint.Y", "PYTHON_9.3")
#Generate output file
out_transect_name = "xs_{}_{}".format(int(round(transect_spacing)),
int(round(transect_width)))
output_transect = os.path.join(output_workspace, out_transect_name)
arcpy.XYToLine_management(Azline_Dissolve, output_transect, "x_start",
"y_start", "x_end", "y_end", "", "",
spatial_reference)
# Create `Seq` field
arcpy.AddField_management(in_table=output_transect,
field_name="Seq",
field_type="SHORT")
arcpy.CalculateField_management(in_table=output_transect,
field="Seq",
expression="!OID!",
expression_type="PYTHON_9.3")
# Set the ReachName field
unique_reaches = set(
row[0] for row in arcpy.da.SearchCursor(flowline, "ReachName"))
reach_name = list(unique_reaches)[0]
arcpy.AddField_management(in_table=output_transect,
field_name="ReachName",
field_type="TEXT")
arcpy.CalculateField_management(in_table=output_transect,
field="ReachName",
expression="'" + reach_name + "'",
expression_type="PYTHON_9.3")
# Return
arcpy.SetParameter(6, output_transect)
# Cleanup
arcpy.Delete_management(General_GDB)
Structure_Pt = arcpy.GetParameterAsText(0)
# Local variables:
Structure_Direction_Reelle_1 = ""
Structure_Direction_Reelle_2 = ""
Structure_Direction_Reelle_Merge = "D:\\Managem\\TriK_2019\\Orpaillage\\Output\\Output.gdb\\Merge"
Structure_Direction_Reelle_shp = "D:\\Managem\\TriK_2019\\Hassan\\Exploration_2019\\Structure\\Structure_Direction_Reelle.shp"
Structure_Pendage_Reelle = "D:\\Managem\\TriK_2019\\Hassan\\Exploration_2019\\Structure\\Structure_Pendage_Reelle.shp"
Structure_Direction_Visible_1 = ""
Structure_Direction_Visible_2 = ""
Structure_Direction_Visible_Merge = "D:\\Managem\\TriK_2019\\Orpaillage\\Output\\Output.gdb\\Merge1"
Structure_Direction_Visible_shp = "D:\\Managem\\TriK_2019\\Hassan\\Exploration_2019\\Structure\\Structure_Direction_Visible.shp"
Structure_Pendage_Visible = "D:\\Managem\\TriK_2019\\Hassan\\Exploration_2019\\Structure\\Structure_Pendage_Visible.shp"
# Process: Bearing Direction Reelle +
arcpy.BearingDistanceToLine_management(Structure_Pt, Structure_Direction_Reelle_1, "X_UTM", "Y_UTM", "Longueur", "9001", "Strike", "9102", "0", "Identifer", "PROJCS['WGS_1984_UTM_Zone_29N',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-9.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]];-5120900 -9998100 450445547.391054;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision")
# Process: Bearing Direction Reelle -
arcpy.BearingDistanceToLine_management(Structure_Pt, Structure_Direction_Reelle_2, "X_UTM", "Y_UTM", "Long_Comp", "9001", "Strike", "9102", "0", "Identifer", "PROJCS['WGS_1984_UTM_Zone_29N',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-9.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]];-5120900 -9998100 450445547.391054;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision")
# Process: Merge Direction Reelle
arcpy.Merge_management("'';''", Structure_Direction_Reelle_Merge, "Identifer \"Identifer\" true true false 0 Text 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Identifer,-1,-1,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Identifer,-1,-1;X_UTM \"X_UTM\" true true false 0 Double 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,X_UTM,-1,-1,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,X_UTM,-1,-1;Y_UTM \"Y_UTM\" true true false 0 Double 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Y_UTM,-1,-1,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Y_UTM,-1,-1;Longueur \"Longueur\" true true false 0 Double 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Longueur,-1,-1;Strike \"Strike\" true true false 0 Double 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Strike,-1,-1,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Strike,-1,-1;Long_Comp \"Long_Comp\" true true false 0 Double 0 0 ,First,#,D:\\Managem\\TriK_2019\\Hassan\\Cartographie.gdb\\Structure_Pt_BearingDistance,Long_Comp,-1,-1")
# Process: Dissolve Direction Reelle
arcpy.Dissolve_management(Structure_Direction_Reelle_Merge, Structure_Direction_Reelle_shp, "Identifer", "", "MULTI_PART", "DISSOLVE_LINES")
# Process: Bearing Pendage Reelle
arcpy.BearingDistanceToLine_management(Structure_Pt, Structure_Pendage_Reelle, "X_UTM", "Y_UTM", "L_Pd_Dir", "9001", "Pd_Dir", "9102", "0", "Identifer", "PROJCS['WGS_1984_UTM_Zone_29N',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-9.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]];-5120900 -9998100 450445547.391054;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision")
# Process: Bearing Direction Visible +
arcpy.BearingDistanceToLine_management(Structure_Pt, Structure_Direction_Visible_1, "X_UTM", "Y_UTM", "Long_Vue", "9001", "Strike", "9102", "0", "Identifer", "PROJCS['WGS_1984_UTM_Zone_29N',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-9.0],PARAMETER['Scale_Factor',0.9996],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]];-5120900 -9998100 450445547.391054;-100000 10000;-100000 10000;0.001;0.001;0.001;IsHighPrecision")
##### 1. extract wind (I used raster data) #####
fn = extract_wind(False,wind,source,0,0,0)
##### 2. defined distance #####
dn = def_dist(source,500)
##### 3. create virtual downiwnd trajectory #####
# re-define arcpy environemnt
arcpy.env.workspace =r"D:\DPRIE_Test\DPRIE.gdb"
road = "road"
DPRIPs = "DPRIP"
bl = "bearline"
# define the spatial reference
sr = arcpy.SpatialReference(54002) #WKID of equidistant cylinderical
bl_path = arcpy.BearingDistanceToLine_management(source, bl, 'X', 'Y',
dn,"METERS",fn, "DEGREES",'GEODESIC',spatial_reference = sr)
print ("creating virtual downiwnd trajectory....")
##### 4. find all DPRIPs #####
dps_path = arcpy.Intersect_analysis ([road, bl],DPRIPs, "", "", 'POINT')
##### 5.find nearest DPRIPs for each source, calculate nearest downiwnd distance #####
# record coordinates of nearest DPRIPs
print ("calculating DPRIPs....")
ID_list,D_wind,Int_x,Int_y,SX,SY = find_n_DPRIP(source,DPRIPs)
# output results to .csv file
d = {"source_X":SX,"source_Y":SY,"source_ID":ID_list,
"Downwind_dist":D_wind,"p_x":Int_x,"p_y":Int_y}
df = pd.DataFrame(data=d,columns = ["source_ID","source_X","source_Y",
