/// <summary> 从 AutoCAD 界面中选择横断面轴线 </summary>
public static SubgradeSection GetSection(DocumentModifier docMdf)
{
SubgradeSection sec = null;
var op = new PromptEntityOptions("\n选择要提取的横断面轴线");
op.AddAllowedClass(typeof(Line), true);
var res = docMdf.acEditor.GetEntity(op);
if (res.Status == PromptStatus.OK)
{
var line = res.ObjectId.GetObject(OpenMode.ForRead) as Line;
if (line != null && line.Layer == Options_LayerNames.LayerName_CenterAxis)
{
var si = SectionInfo.FromCenterLine(line);
if (si != null && si.FullyCalculated)
{
sec = new SubgradeSection(docMdf, line, si);
}
else
{
MessageBox.Show($"选择的道路中心线对象所对应的横断面未进行构造，" +
$"\r\n请先调用“{SectionsConstructor.CommandName}”命令，以构造整个项目的横断面系统。",
"提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
return(sec);
}
private static double GetCutY(SlopeData slp, SubgradeSection sec, CutMethod method, double value)
{
double cutY = 0;
switch (method)
{
case CutMethod.从中心向外:
if (slp.FillCut)
{
cutY = sec.GetYFromElev(slp.TopElevation - value);
break;
}
else
{
cutY = sec.GetYFromElev(slp.BottomElevation + value);
break;
}
case CutMethod.从坡底向上:
cutY = sec.GetYFromElev(slp.BottomElevation + value);
break;
case CutMethod.从坡顶向下:
cutY = sec.GetYFromElev(slp.TopElevation - value);
break;
default: // 按绝对标高
cutY = sec.GetYFromElev(value);
break;
}
return(cutY);
}
/// <summary> 浅挖路堑 </summary>
/// <param name="centerAxis"></param>
/// <param name="width">左右路堑坡顶之间的宽度</param>
/// <param name="height"> 路堑处理的高度，指 *-**</param>
/// <returns></returns>
public static bool IsShallowCut(Database db, SubgradeSection centerAxis, out double width, out double height)
{
var center = centerAxis.XData;
width = 0.0;
// 浅挖路堑的路槽底部以下地基处理的高度
height = _criterion.浅挖处理高度; // center.CenterElevation_Ground - center.CenterElevation_Road;
var cutDepth = center.CenterElevation_Ground - center.CenterElevation_Road;
// 1. 基本判断标准：零填及挖方小于0.5m，路槽底应进行翻挖压实，翻挖深度以保证路槽下处理深度不小于0.8m
if (cutDepth >= 0 && cutDepth <= _criterion.浅挖最大深度)
{
// 浅挖路基的翻挖压实处理的最底部距离路面顶的深度，一般为1.5m左右
var tb = (center.GetEleFromY(center.CenterY) - center.CenterElevation_Cushion) + _criterion.浅挖处理高度;
;
// 计算左右半边道路的挖填情况
// 当边坡为填方时（且道路中线处为挖方），此时自然地面线一般会与路面线相交，返回相交后靠近道路中线侧的挖方宽度；
// 如果自然地面线与路面线不相交（），则将此侧道路按全挖方考虑，且为全浅挖
var leftGround = center.LeftGroundSurfaceHandle.GetDBObject <Polyline>(db);
var rightGround = center.RightGroundSurfaceHandle.GetDBObject <Polyline>(db);
double leftCenterCutWidth = HalfRoadShallowCut(center, true, center.LeftSlopeFill, tb, leftGround);
double rightCenterCutWidth = HalfRoadShallowCut(center, false, center.RightSlopeFill, tb, rightGround);
//
width = leftCenterCutWidth + rightCenterCutWidth;
return(true);
}
return(false);
}
/// <summary> 陡坡路堤 </summary>
/// <param name="sec"> 道路中心填方高度</param>
/// <param name="treatedSide"> 哪一侧需要进行陡坡路堤处理 </param>
/// <param name="treatedWidth"> 陡坡路堤处理宽度 </param>
/// <param name="stairArea"> 挖台阶的面积 </param>
/// <param name="reinforcementSide"> 哪一侧需要设置加筋结构，比如铺设三层土工格栅</param>
/// <returns></returns>
private bool IsSteepSlope(SubgradeSection sec, out SectionSide treatedSide, out double treatedWidth,
out double stairArea,
out SectionSide reinforcementSide)
{
bool isSteep = false;
treatedWidth = 0;
stairArea = 0;
double sideTreatedWidth = 0;
double sideStairArea = 0;
treatedSide = SectionSide.无;
reinforcementSide = SectionSide.无;
bool leftSetReinforcement;
bool rightSetReinforcement;
var secData = sec.XData;
//
SlopeLine sideSlope = null;
Polyline sideGround = null;
if (secData.LeftRetainingWallType != RetainingWallType.路肩墙)
{
sideSlope = sec.GetSlopeLine(true); // 断面左侧边坡
sideGround = secData.LeftGroundSurfaceHandle.GetDBObject <Polyline>(_docMdf.acDataBase);
if (IsSteepFill(secData, true, sideSlope, sideGround, out sideTreatedWidth, out sideStairArea,
out leftSetReinforcement))
{
isSteep = true;
treatedSide = treatedSide | SectionSide.左;
reinforcementSide = leftSetReinforcement ? reinforcementSide | SectionSide.左 : reinforcementSide;
treatedWidth += sideTreatedWidth;
stairArea += sideStairArea;
}
}
if (secData.RightRetainingWallType != RetainingWallType.路肩墙)
{
sideSlope = sec.GetSlopeLine(false); // 断面右侧边坡
sideGround = secData.RightGroundSurfaceHandle.GetDBObject <Polyline>(_docMdf.acDataBase);
if (IsSteepFill(secData, false, sideSlope, sideGround, out sideTreatedWidth, out sideStairArea,
out rightSetReinforcement))
{
isSteep = true;
treatedSide = treatedSide | SectionSide.右;
reinforcementSide = rightSetReinforcement ? reinforcementSide | SectionSide.右 : reinforcementSide;
treatedWidth += sideTreatedWidth;
stairArea += sideStairArea;
}
}
return(isSteep);
}
// This event handler is where the time-consuming work is done.
private void ConstructSections_DoWork(System.Object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = (BackgroundWorker)sender;
var errorCenterLine = new Dictionary <Line, string>();
string errorMsg = "";
for (int i = 0; i < _count; i++)
{
var axis = _centerLines[i];
var cenA = SubgradeSection.Create(_docMdf, axis, out errorMsg);
if (cenA != null)
{
cenA.CenterLine.UpgradeOpen();
cenA.ClearXData(true);
var succ = cenA.CalculateSectionInfoToXData(errorMsg);
if (succ)
{
cenA.FlushXData();
SectionAxes.Add(cenA);
}
else
{
errorCenterLine.Add(axis, errorMsg);
}
cenA.CenterLine.DowngradeOpen();
}
else
{
errorCenterLine.Add(axis, errorMsg);
}
// 显示进度
worker.ReportProgress(i);
}
// 列出出错的断面
if (errorCenterLine.Count > 0)
{
_docMdf.WriteLineIntoDebuger("提取出错的断面：");
_docMdf.WriteLineIntoDebuger("序号 起点 终点 报错");
int index = 0;
var acPoly = new Polyline();
foreach (var ecl in errorCenterLine)
{
var pt = new Point2d(ecl.Key.StartPoint.X, ecl.Key.StartPoint.Y);
acPoly.AddVertexAt(index, pt, 0, startWidth: 0, endWidth: 0);
_docMdf.WriteLineIntoDebuger(index + 1, ecl.Key.StartPoint, ecl.Key.EndPoint, ecl.Value);
index += 1;
}
}
}
/// <summary> 在 AutoCAD 界面中快速导航到指定的桩号 </summary>
public ExternalCmdResult NavigateStation(DocumentModifier docMdf, SelectionSet impliedSelection)
{
_docMdf = docMdf;
SubgradeSection matchedSection = null;
bool? start;
var wantedStation = SetStation(docMdf.acEditor, out start);
// 所有的断面
var allSections = SQUtils.GetAllSections(docMdf, sort: true);
if (allSections != null && allSections.Length > 0)
{
if (start.HasValue)
{
// 匹配起始或者结尾桩号
if (start.Value)
{
matchedSection = allSections[0];
}
else
{
matchedSection = allSections[allSections.Length - 1];
}
}
else
{
// 匹配指定数值最近的桩号
if (wantedStation.HasValue)
{
var allStations = new AllStations(allSections.Select(r => r.XData.Station).ToArray());
var closestStation = allStations.MatchClosest(wantedStation.Value);
matchedSection = allSections.FirstOrDefault(r => r.XData.Station == closestStation);
}
}
//
if (matchedSection != null)
{
var ext = matchedSection.GetExtends();
ext.TransformBy(Matrix3d.Scaling(
scaleAll: 1.2,
center: ext.MinPoint.Add((ext.MaxPoint - ext.MinPoint) / 2)));
eZcad.Utility.Utils.ShowExtentsInView(docMdf.acEditor, ext);
}
}
return(ExternalCmdResult.Commit);
}
/// <summary> 填方或土质路堑路段 </summary>
/// <param name="sec"> 道路中心填方高度</param>
/// <returns></returns>
private bool IsFillOrSoilCut(SubgradeSection sec)
{
var secData = sec.XData;
if ((secData.LeftSlopeFill != null && !secData.LeftSlopeFill.Value) &&
(secData.RightSlopeFill != null && !secData.RightSlopeFill.Value))
{
var leftSlope = sec.GetSlopeLine(true); // 断面左侧边坡
var rightSlope = sec.GetSlopeLine(true); // 断面左侧边坡
if (leftSlope != null && leftSlope.XData.SoilOrRock == SubgradeType.岩质 &&
rightSlope != null && rightSlope.XData.SoilOrRock == SubgradeType.岩质)
{
return(false); // 石质路堑路段
}
}
return(true); // 填方或土质路堑路段
}
/// <summary> 软基填方 </summary>
/// <param name="centerAxis"></param>
/// <param name="treatedGroundLength"> 软弱地基宽度（两侧路基范围内的自然地面宽度，加上附加换填宽度）</param>
/// <returns></returns>
public static bool IsSoftSub(Database db, SubgradeSection centerAxis, out double treatedGroundLength)
{
var center = centerAxis.XData;
bool isSoftSubs = false;
treatedGroundLength = 0.0;
// 1. 基本判断标准
if (!center.IsCenterFill())
{
return(false);
}
var centerDepth = center.CenterElevation_Road - center.CenterElevation_Ground;
// 低填加固厚度
var thinFillTreatedDepth = _thinFillCriterion.低填处理高度 - centerDepth;
if ((centerDepth > _softSubCriterion.薄层厚度) ||
(_softSubCriterion.换填厚度 - thinFillTreatedDepth < _softSubCriterion.最小换填厚度))
{
// 如果除去低填处理的厚度T之后，剩下的换填厚度(D-T)还大于此最小换填厚度"，则认为此断面应该计入D的换填厚度
return(false);
}
// 限制填方路基范围内的自然地面不能过陡，以过滤到陡坡路堤或者挖台阶时的重复处理
// 2. 边坡的坡底点
var leftBottom = center.LeftSlopeExists
? center.LeftSlopeHandle.GetDBObject <Polyline>(db).EndPoint
: center.LeftRoadSurfaceHandle.GetDBObject <Polyline>(db).EndPoint;
var rightBottom = center.RightSlopeExists
? center.RightSlopeHandle.GetDBObject <Polyline>(db).EndPoint
: center.RightRoadSurfaceHandle.GetDBObject <Polyline>(db).EndPoint;
// private bool IsSideSoftSub(Database db, SectionInfo section, Point3d slopeBottom, out double treatedLength)
double leftTreatedGroundLength;
double rightTreatedGroundLength;
bool isLeftSideSoftSub = IsSideSoftSub(db, center, true, leftBottom, out leftTreatedGroundLength);
bool isRightSideSoftSub = IsSideSoftSub(db, center, false, rightBottom, out rightTreatedGroundLength);
treatedGroundLength = leftTreatedGroundLength + rightTreatedGroundLength;
//
return(leftTreatedGroundLength + rightTreatedGroundLength > 0.1);
}
/// <summary> 判断路面类型 </summary>
/// <param name="sec"> 道路中心填方高度</param>
/// <returns></returns>
private RoadSurfaceType GetRoadSurfaceType(SubgradeSection sec)
{
// 从工程量偏大的角度考虑
// 左右侧有一侧为填方，则认为此路面为填方；
// 左右侧有一侧为土质，则认为此路面为土质；
var secData = sec.XData;
bool isFill = (secData.LeftSlopeFill == null) || (secData.LeftSlopeFill.Value) ||
(secData.RightSlopeFill == null) || (secData.RightSlopeFill.Value);
bool isSoil = true;
var leftSlope = sec.GetSlopeLine(true); // 断面左侧边坡
var rightSlope = sec.GetSlopeLine(false); // 断面左侧边坡
isSoil = (leftSlope != null && leftSlope.XData.SoilOrRock == SubgradeType.土质) ||
(rightSlope != null && rightSlope.XData.SoilOrRock == SubgradeType.土质);
//
if (isFill)
{
if (isSoil)
{
return(RoadSurfaceType.填方土质);
}
else
{
return(RoadSurfaceType.填方岩质);
}
}
else
{
if (isSoil)
{
return(RoadSurfaceType.挖方土质);
}
else
{
return(RoadSurfaceType.挖方岩质);
}
}
}
/// <summary> 从整个项目中获取全部的横断面所对应的桩号（不要求界面全部显示）。集合中的元素未按桩号值进行排序 </summary>
/// <param name="sort">是否要对所有横断面按桩号从小到大排序</param>
public static SubgradeSection[] GetAllSections(DocumentModifier docMdf, bool sort)
{
var stations = new List <SubgradeSection>();
var res = docMdf.acEditor.SelectAll(SubgradeSection.Filter);
if (res.Status == PromptStatus.OK)
{
var ids = res.Value.GetObjectIds();
foreach (var id in ids)
{
SubgradeSection centerLine = null;
var l = id.GetObject(OpenMode.ForRead) as Line;
if (l != null)
{
var si = SectionInfo.FromCenterLine(l);
if (si != null && si.FullyCalculated)
{
centerLine = new SubgradeSection(docMdf, l, si);
stations.Add(centerLine);
}
}
if (centerLine == null)
{
MessageBox.Show($"某些道路中心线对象所对应的横断面未进行构造，" +
$"\r\n请先调用“{SectionsConstructor.CommandName}”命令，以构造整个项目的横断面系统。",
"提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
}
}
if (sort)
{
stations.Sort(CompareStation);
}
return(stations.ToArray());
}
/// <summary> 填方边坡类型 </summary>
/// <param name="sec"> 道路中心填方高度</param>
/// <param name="treatedWidth"> 陡坡路堤处理宽度 </param>
/// <param name="treatedSide"> 要进行挖台阶处理的是断面的哪一侧 </param>
/// <param name="stairArea">某一侧边坡所挖台阶面积</param>
/// <returns></returns>
private FillSlopeType GetFillSlopeType(SubgradeSection sec, out SectionSide treatedSide, out double treatedWidth, out double stairArea)
{
var sectionfillSlopeType = FillSlopeType.Other;
treatedWidth = 0;
stairArea = 0.0;
double sideTreatedWidth = 0;
double sideStairArea = 0.0;
treatedSide = SectionSide.无;
var secData = sec.XData;
//
var sideSlope = sec.GetSlopeLine(true); // 断面左侧边坡
var sideGround = secData.LeftGroundSurfaceHandle.GetDBObject <Polyline>(_docMdf.acDataBase);
var fillSlopeType = GetFillSlopeType(secData, true, sideSlope, sideGround, out sideTreatedWidth, out sideStairArea);
if (fillSlopeType == FillSlopeType.StairExcav)
{
sectionfillSlopeType = FillSlopeType.StairExcav;
treatedSide = treatedSide | SectionSide.左;
treatedWidth += sideTreatedWidth;
stairArea += sideStairArea;
}
sideSlope = sec.GetSlopeLine(false); // 断面右侧边坡
sideGround = secData.RightGroundSurfaceHandle.GetDBObject <Polyline>(_docMdf.acDataBase);
fillSlopeType = GetFillSlopeType(secData, false, sideSlope, sideGround, out sideTreatedWidth, out sideStairArea);
if (fillSlopeType == FillSlopeType.StairExcav)
{
sectionfillSlopeType = FillSlopeType.StairExcav;
treatedSide = treatedSide | SectionSide.右;
treatedWidth += sideTreatedWidth;
stairArea += sideStairArea;
}
return(sectionfillSlopeType);
}
/// <summary>
///
/// </summary>
/// <param name="allSections"></param>
/// <param name="left"></param>
/// <param name="retainingWalls">每一个桩号所对应的某一侧的挡墙顶与挡墙底相对于道路中线的高度，如果某桩号中没有挡墙，则其值为 null</param>
/// <returns>每一个桩号所对应的开口线相对于道路中线的高度。</returns>
private Dictionary <double, double> ConstructLeftSlope(SubgradeSection[] allSections, bool left,
out Dictionary <double, double[]> retainingWalls)
{
var slps = new Dictionary <double, double>();
retainingWalls = new Dictionary <double, double[]>();
SubgradeSection errorSection = null;
try
{
foreach (var sec in allSections)
{
errorSection = sec;
var xdata_Section = sec.XData;
if (left)
{
// 边坡
if (xdata_Section.LeftSlopeExists)
{
var spline = sec.GetSlopeLine(true);
var xdata = spline.XData;
var height = 0.0;
if (xdata.Slopes.Any())
{
height = xdata.Slopes.Last().OuterPoint.Y - xdata_Section.CenterY;
}
else
{
var edgeElevation = xdata.FillCut ? xdata.BottomElevation : xdata.TopElevation;
height = edgeElevation - xdata_Section.CenterElevation_Road;
}
slps.Add(xdata_Section.Station, height);
}
else
{
slps.Add(xdata_Section.Station, 0);
}
// 挡墙
var retainingWall = xdata_Section.LeftRetainingWallType != RetainingWallType.无
? xdata_Section.LeftRetainingWallHandle.GetDBObject <Polyline>(sec.DocMdf.acDataBase)
: null;
if (retainingWall != null)
{
var rtw = new RetainingWall(retainingWall);
var topY = rtw.GetTopY();
var bottomY = rtw.GetBottomY();
retainingWalls.Add(xdata_Section.Station,
new double[] { topY - xdata_Section.CenterY, bottomY - xdata_Section.CenterY });
}
else
{
retainingWalls.Add(xdata_Section.Station, null);
}
}
else
{
if (xdata_Section.RightSlopeExists)
{
var spline = sec.GetSlopeLine(false);
var xdata = spline.XData;
var height = 0.0;
if (spline.XData.Slopes.Any())
{
height = spline.XData.Slopes.Last().OuterPoint.Y - xdata_Section.CenterY;
}
else
{
var edgeElevation = xdata.FillCut ? xdata.BottomElevation : xdata.TopElevation;
height = edgeElevation - xdata_Section.CenterElevation_Road;
}
slps.Add(xdata_Section.Station, height);
}
else
{
slps.Add(xdata_Section.Station, 0);
}
// 挡墙
var retainingWall = xdata_Section.RightRetainingWallType != RetainingWallType.无
? xdata_Section.RightRetainingWallHandle.GetDBObject <Polyline>(sec.DocMdf.acDataBase)
: null;
if (retainingWall != null)
{
var rtw = new RetainingWall(retainingWall);
var topY = rtw.GetTopY();
var bottomY = rtw.GetBottomY();
retainingWalls.Add(xdata_Section.Station,
new double[] { topY - xdata_Section.CenterY, bottomY - xdata_Section.CenterY });
}
else
{
retainingWalls.Add(xdata_Section.Station, null);
}
}
}
}
catch (Exception ex)
{
if (errorSection != null)
{
var leftSide = left ? "左" : "右";
var errMsg = $"构造{leftSide}边的边坡线数据时出错，出错桩号为{errorSection.XData.Station}。\r\n {ex.StackTrace}";
MessageBox.Show(errMsg, "出错", MessageBoxButton.OK, MessageBoxImage.Error);
// throw new InvalidOperationException(errMsg, ex);
return(slps);
}
}
return(slps);
}
/// <summary> 桩号小的在前面 </summary>
public static int CompareStation(SubgradeSection slopeData1, SubgradeSection slopeData2)
{
return(slopeData1.XData.Station.CompareTo(slopeData2.XData.Station));
}
/// <summary> 低填路堤 </summary>
/// <param name="centerAxis"></param>
/// <param name="width"> 左右路堤坡底之间的宽度</param>
/// <param name="height"> 自然地面以下地基加固的高度</param>
/// <returns></returns>
public static bool IsThinFill(Database db, SubgradeSection centerAxis, out double width, out double height)
{
var center = centerAxis.XData;
height = 0.0;
width = 0.0;
// 1. 基本判断标准
var depth = center.CenterElevation_Road - center.CenterElevation_Ground;
double leftWidth1 = 0.0;
double rightWidth1 = 0.0;
// 道路中心为填方，而且左右至少有一侧为填方边坡
if (depth >= 0 && depth <= _criterion.低填最大高度 &&
((center.LeftSlopeFill == null || center.LeftSlopeFill.Value) ||
(center.RightSlopeFill == null || center.RightSlopeFill.Value)))
{
// 道路中心线 与 自然地面线的交点
var centerGroundPt = new Point3d(center.CenterX, center.GetYFromElev(center.CenterElevation_Ground), 0);
// 左侧低填处理的宽度
var leftRoadWidth = center.CenterX - center.LeftRoadEdge.X;
if (center.LeftSlopeFill == null || !center.LeftSlopeFill.Value)
{
// 无边坡线或者是挖方
leftWidth1 = leftRoadWidth;
}
else
{
var leftSlope = center.LeftSlopeHandle.GetDBObject <Polyline>(db);
if (leftSlope == null)
{
leftWidth1 = leftRoadWidth;
}
else
{
// 先计算填方边坡线与
var leftInters = new CurveCurveIntersector2d(leftSlope.Get2dLinearCurve(),
new Ray2d(centerGroundPt.ToXYPlane(), new Vector2d(-1, 0)));
if (leftInters.NumberOfIntersectionPoints == 0)
{
leftWidth1 = leftRoadWidth;
}
else
{
leftWidth1 = Math.Abs(leftInters.GetIntersectionPoint(0).X - center.CenterX);
}
}
}
// 右侧低填处理的宽度
var rightRoadWidth = center.RightRoadEdge.X - center.CenterX;
if (center.RightSlopeFill == null || !center.RightSlopeFill.Value)
{
// 无边坡线或者是挖方
rightWidth1 = rightRoadWidth;
}
else
{
var rightSlope = center.RightSlopeHandle.GetDBObject <Polyline>(db);
if (rightSlope == null)
{
rightWidth1 = rightRoadWidth;
}
else
{
// 先计算填方边坡线与
var rightInters = new CurveCurveIntersector2d(rightSlope.Get2dLinearCurve(),
new Ray2d(centerGroundPt.ToXYPlane(), new Vector2d(1, 0)));
if (rightInters.NumberOfIntersectionPoints == 0)
{
rightWidth1 = rightRoadWidth;
}
else
{
rightWidth1 = Math.Abs(rightInters.GetIntersectionPoint(0).X - center.CenterX);
}
}
}
width = leftWidth1 + rightWidth1;
//
if (width > 0)
{
// 低填路堤的自然地面下部地基处理的高度
height = _criterion.低填处理高度 - (center.CenterElevation_Road - center.CenterElevation_Ground);
if (height < 0)
{
height = 0;
}
return(true);
}
}
return(false);
}
/// <summary> 填方或土质路堑路段 </summary>
/// <param name="sec"> 道路中心填方高度</param>
/// <param name="hardShouderCount"> 道路中心填方高度</param>
/// <returns></returns>
private bool HasHardShoulder(SubgradeSection sec, out int hardShouderCount,
out HardShoulderType leftType, out HardShoulderType rightType, out double leftHardShoulerArea, out double rightHardShoulerArea)
{
hardShouderCount = 0;
leftHardShoulerArea = 0;
rightHardShoulerArea = 0;
leftType = HardShoulderType.无;
rightType = HardShoulderType.无;
var secData = sec.XData;
// 对左侧进行判断与计量
if (secData.LeftSlopeFill != null && secData.LeftSlopeFill.Value)
{
// 表示是填方路段，接下来判断路肩类型
if (secData.LeftRetainingWallType == RetainingWallType.路肩墙)
{
leftType = HardShoulderType.挡墙;
hardShouderCount += 1;
leftHardShoulerArea = _criterion.路肩面积_挡墙;
}
else
{
// 通过填方边坡高度来确定是否需要设置护栏
double fillHeight;
var leftSlp = sec.GetSlopeLine(true);
fillHeight = Math.Abs(leftSlp.Pline.StartPoint.Y - leftSlp.Pline.EndPoint.Y);
if (fillHeight >= _criterion.设护栏段的填方高度)
{
leftType = HardShoulderType.护栏;
hardShouderCount += 1;
leftHardShoulerArea = _criterion.路肩面积_护栏;
}
else
{
leftType = HardShoulderType.无护栏;
hardShouderCount += 1;
leftHardShoulerArea = _criterion.路肩面积_无护栏;
}
}
}
// 对右侧进行判断与计量
if (secData.RightSlopeFill != null && secData.RightSlopeFill.Value)
{
// 表示是填方路段，接下来判断路肩类型
if (secData.RightRetainingWallType == RetainingWallType.路肩墙)
{
rightType = HardShoulderType.挡墙;
hardShouderCount += 1;
rightHardShoulerArea = _criterion.路肩面积_挡墙;
}
else
{
// 通过填方边坡高度来确定是否需要设置护栏
double fillHeight;
var rightSlp = sec.GetSlopeLine(false);
fillHeight = Math.Abs(rightSlp.Pline.StartPoint.Y - rightSlp.Pline.EndPoint.Y);
if (fillHeight >= _criterion.设护栏段的填方高度)
{
rightType = HardShoulderType.护栏;
hardShouderCount += 1;
rightHardShoulerArea = _criterion.路肩面积_护栏;
}
else
{
rightType = HardShoulderType.无护栏;
hardShouderCount += 1;
rightHardShoulerArea = _criterion.路肩面积_无护栏;
}
}
}
//
return(hardShouderCount > 0);
}
