/// <summary>
///追踪处理单元中的射线
/// </summary>
/// <param name="tx">发射机</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <param name="unit">射线处理单元</param>
/// <returns></returns>
private void TracingUnitRay(RayTracingModel unit, Node tx, Terrain ter, ReceiveArea reArea, City cityBuilding, List <FrequencyBand> txFrequencyBand)
{
//追踪射线1
if (unit.FirstRay.WhetherHaveTraced == false)//若该射线之前还没有追踪
{
RayInfo newRay = new RayInfo(unit.FirstRay.Origin, unit.FirstRay.SVector);
List <Path> pathtemp = this.GetSingleRayPaths(tx, ter, reArea, cityBuilding, newRay, txFrequencyBand);
unit.FirstRay.Flag = JudgeIfArriveRx(pathtemp);
unit.FirstRay.Path = pathtemp;
unit.FirstRay.WhetherHaveTraced = true;
}
//追踪射线2
if (unit.SecondRay.WhetherHaveTraced == false)//若该射线之前还没有追踪
{
RayInfo newRay = new RayInfo(unit.SecondRay.Origin, unit.SecondRay.SVector);
List <Path> pathtemp = this.GetSingleRayPaths(tx, ter, reArea, cityBuilding, newRay, txFrequencyBand);
unit.SecondRay.Flag = JudgeIfArriveRx(pathtemp);
unit.SecondRay.Path = pathtemp;
unit.FirstRay.WhetherHaveTraced = true;
}
//追踪射线3
if (unit.ThirdRay.WhetherHaveTraced == false)//若该射线之前还没有追踪
{
RayInfo newRay = new RayInfo(unit.ThirdRay.Origin, unit.ThirdRay.SVector);
List <Path> pathtemp = this.GetSingleRayPaths(tx, ter, reArea, cityBuilding, newRay, txFrequencyBand);
unit.ThirdRay.Flag = JudgeIfArriveRx(pathtemp);
unit.ThirdRay.Path = pathtemp;
unit.FirstRay.WhetherHaveTraced = true;
}
unit.HaveTraced = true;
return;
}
/// <summary>
///初始阶段在每个三角形上发出一定的射线
/// </summary>
/// <param name="tx">发射机</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="N">三角形处理单元每条边取点个数</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <param name="divideAngle">射线束夹角</param>
/// <returns>返回对正二十面体每个三角面初始细分后得到的多个处理单元</returns>
private List <RayTracingModel> GetInitialTrianglePath(Node tx, Terrain ter, ReceiveArea reArea, City cityBuilding, RayTracingModel unit, int N, double divideAngle, List <FrequencyBand> txFrequencyBand)
{
Point vertex1 = new Point(unit.FirstRay.SVector); //三角形的顶点
Point vertex2 = new Point(unit.SecondRay.SVector); //三角形的顶点
Point vertex3 = new Point(unit.ThirdRay.SVector); //三角形的顶点
SpectVector vector12 = new SpectVector(vertex1, vertex2);
SpectVector vector23 = new SpectVector(vertex2, vertex3);
double length = vertex1.GetDistance(vertex2) / N; //每段的距离
Point[] pointOfEdge12 = new Point[N]; //存放棱上的点,不包括顶点1
// p1[0] = vertex1;
for (int i = 0; i < N; i++)
{
pointOfEdge12[i] = new Point(vertex1.X + (i + 1) * (vector12.a / Math.Sqrt(Math.Pow(vector12.a, 2) + Math.Pow(vector12.b, 2) + Math.Pow(vector12.c, 2)) * length), vertex1.Y + (i + 1) * (vector12.b / Math.Sqrt(Math.Pow(vector12.a, 2) + Math.Pow(vector12.b, 2) + Math.Pow(vector12.c, 2)) * length), vertex1.Z + (i + 1) * (vector12.c / Math.Sqrt(Math.Pow(vector12.a, 2) + Math.Pow(vector12.b, 2) + Math.Pow(vector12.c, 2)) * length));
}
List <Point>[] vertexPoints = new List <Point> [N + 1];//存放三角形内每条平行边上的点
for (int k = 0; k <= N; k++)
{
vertexPoints[k] = new List <Point>();
}
vertexPoints[0].Add(vertex1);
for (int j = 1; j <= N; j++)//得到三角形切分后每条边上的点
{
vertexPoints[j].Add(pointOfEdge12[j - 1]);
this.GetTriangleInternalEdgePoint(vector23, pointOfEdge12[j - 1], length, j, vertexPoints[j]);
}
List <ClassNewRay>[] raysPath = this.GetEachTriangleRay(tx, ter, reArea, cityBuilding, N, txFrequencyBand, vertexPoints); //根据得到的点构造射线
List <RayTracingModel> triangleUnits = this.HandleInitialRayToUnit(raysPath); //得到初始追踪完的三角形处理单元
return(triangleUnits);
}
/// <summary>
///获取态势区域分块中心点
/// </summary>
/// <param name="reArea">态势区域</param>
/// <param name="rxCounter">态势区域X,Y上分段个数</param>
/// <param name="terRect">地形矩形</param>
/// <param name="index">当前分块的信息</param>
/// <param temp="terRect">前台设置的高度</param>
/// <returns></returns>
public static Point GetCenterPointInAreaDivision(ReceiveArea reArea, List <int> rxCounter, Terrain ter, int index, double temp)
{
Point centerTemp = new Point();
int test1 = (index - 1) % rxCounter[0];
int test2 = (index - 1 - test1) / rxCounter[0];
//centerTemp.x=area.origen.x+area.spacing/2+test1*area.spacing;
//centerTemp.y = area.origen.y + area.spacing / 2 + test2 * area.spacing;
if (test1 != rxCounter[0] - 1)
{
centerTemp.X = reArea.OriginPoint.X + test1 * reArea.spacing;
}
else
{
centerTemp.X = reArea.OriginPoint.X + reArea.rxLength;
}
if (test2 != rxCounter[1] - 1)
{
centerTemp.Y = reArea.OriginPoint.Y + test2 * reArea.spacing;
}
else
{
centerTemp.Y = reArea.OriginPoint.Y + reArea.rxWidth;
}
SetCenterPointZValue(centerTemp, ter);
centerTemp.Z += temp;
return(centerTemp);
}
/// <summary>
/// 将两个点连起来，然后用用spacing长度取点，存放入List中
/// </summary>
/// <param name="rxNode1">当前节点</param>
/// <param name="reArea">态势区域</param>
/// <param name="rxNode2">下一个节点</param>
/// <param name="spacing">间隔</param>
/// <returns></returns>
private List <Node> makeNodesInTheLine(Node rxNode1, Node rxNode2, ReceiveArea reArea, double spacing)
{
List <Node> rxNodes = new List <Node>();
double distance = rxNode1.Position.GetDistance(rxNode2.Position);
if (distance < spacing)
{
Node newNode = this.MakeAreaRxNode(rxNode1, rxNode2, reArea, 0.5 * distance);
rxNodes.Add(newNode);
}
else
{
int index = 0;
if (distance % spacing == 0)
{
index = (int)(distance / spacing) - 1;
}
else
{
index = (int)(distance / spacing);
}
for (int i = 1; i <= index; i++)
{
//做新点的生成
Node newNode = this.MakeAreaRxNode(rxNode1, rxNode2, reArea, spacing * i);
rxNodes.Add(newNode);
}
}
return(rxNodes);
}
/// <summary>
///全向静态发射射线
/// </summary>
/// <param name="currentNode">节点</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="N">细分点个数</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <returns></returns>
private List <Path> LuanchRaysOmnidirectionalInArea(Node tx, ReceiveArea reArea, Terrain ter, City cityBuilding, int N, List <FrequencyBand> txFrequencyBand)
{
List <Path> pathInfo = new List <Path>();
List <RayTracingModel> originUnits = this.GetOriginUnitsOfIcosahedron(tx);
HandleEachSurface(originUnits, pathInfo, tx, reArea, ter, cityBuilding, N, txFrequencyBand);
return(pathInfo);
}
public static List <int> getCount4Rx(ReceiveArea rArea)
{
List <int> count = new List <int>();
int countX = rArea.rxLength % rArea.spacing == 0 ? (int)(rArea.rxLength / rArea.spacing) : (int)(rArea.rxLength / rArea.spacing) + 1;
int countY = rArea.rxWidth % rArea.spacing == 0 ? (int)(rArea.rxWidth / rArea.spacing) : (int)(rArea.rxWidth / rArea.spacing) + 1;
count.Add(countX);
count.Add(countY);
return(count);
}
public List <Path> AreaMethod(Node tx, Terrain ter, ReceiveArea reArea, List <FrequencyBand> txFrequencyBand, List <RayInfo> list = null)
{
// RayPath.GetTransPathArea(ter, tx, reArea,txFrequencyBand, list);
List <CalculateModelClasses.Path> temp = new List <CalculateModelClasses.Path>();
// if (tx.ChildNodes.Count != 0)
// {
// temp = RayPath.GetLegalPathsArea(tx);
// }
tx.ChildNodes.Clear();
return(temp);
}
/// <summary>
///求从辐射源发出的一条射线的所有路径
/// </summary>
/// <param name="tx">发射机</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <param name="inRay">发射射线</param>
/// <returns>该射线产生的路径</returns>
private List <Path> GetSingleRayPaths(Node tx, Terrain ter, ReceiveArea reArea, City cityBuilding, RayInfo inRay, List <FrequencyBand> txFrequencyBand)
{
// inRay = new RayInfo(tx.Position, new SpectVector(-0.27911979649,-0.52392969013, -0.55086104634));
//AreaPath newPaths = new AreaPath(inRay, ter,reArea);
//newPaths.SetAreaRayPathNodes(tx, ter, reArea, cityBuilding, txFrequencyBand);
List <Path> temp = new List <Path>();
if (tx.ChildNodes.Count != 0)
{
temp = this.GetLegalPathsArea(tx);
tx.tempNode = null;
}
return(temp);
}
/// <summary>
///求射线与地形,态势区域,建筑物的交点,并将交点按照与源点距离进行排序
/// </summary>
/// <param name="oneRay">射线</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <param name="multiple">绕射圆柱体半径倍数</param>
/// <returns>返回交点</returns>
private List <Node> GetCrossPointsWithEnvironment(ReceiveArea reArea, City cityBuilding, List <FrequencyBand> txFrequencyBand, double multiple)
{
Node crossWithTer = this.inRay.GetCrossNodeWithTerrainRects(this.terShadowRects); //记录射线与地形交点、与源点距离、所在面
List <Node> CrossWithArea = this.GetCrossNodesOfRayAndArea(reArea); //记录射线与态势区域交点
List <Node> CrossWithTerEdge = this.GetCrossNodeWithTerDiffractionEdge(txFrequencyBand, multiple); //记录射线与地形绕射边的交点，绕射等信息
Node crossWithCity = cityBuilding.GetReflectionNodeWithCity(this.inRay); //记录射线与建筑物交点、与源点距离、所在面
List <Node> CrossWithCityEdge = cityBuilding.GetDiffractionNodeWithCity(this.inRay, txFrequencyBand, multiple); //记录射线与建筑物绕射边的交点，绕射等信息
//把所有交点放到一个list中
List <Node> crossNodes = new List <Node>();
if (crossWithTer != null)
{
crossNodes.Add(crossWithTer);
}
if (CrossWithArea.Count != 0)
{
crossNodes.AddRange(CrossWithArea);
}
if (crossWithCity != null)
{
crossNodes.Add(crossWithCity);
}
if (CrossWithTerEdge.Count != 0)
{
crossNodes.AddRange(CrossWithTerEdge);
}
if (CrossWithCityEdge.Count != 0)
{
crossNodes.AddRange(CrossWithCityEdge);
}
//
if (crossNodes.Count > 1)//若交点个数大于2，进行排序
{
for (int i = 0; i < crossNodes.Count - 1; i++)
{
for (int j = 0; j < crossNodes.Count - i - 1; j++)
{
if (crossNodes[j].DistanceToFrontNode > crossNodes[j + 1].DistanceToFrontNode)
{
Node param = crossNodes[j];
crossNodes[j] = crossNodes[j + 1];
crossNodes[j + 1] = param;
}
}
}
}
this.DeleteSameNodesInArea(crossNodes);
return(crossNodes);
}
/// <summary>
///求射线与接收区域的交点
/// </summary>
/// <param name="areaRect">射线可能经过的矩形的范围</param>
/// <returns>射线与接收区域的交点</returns>
private List <Node> GetCrossNodesOfRayAndArea(ReceiveArea recArea)
{
List <Node> crossNodes = new List <Node>();
//与态势区域上顶面的交点
for (int i = 0; i < this.areaTopSideShadowRects.Count; i++)
{
Node crossNode1 = this.inRay.GetCrossNodeWithOriginTriangle(this.areaTopSideShadowRects[i].TriangleOne);
if (crossNode1 != null)
{
crossNodes.Add(crossNode1);
}
Node crossNode2 = this.inRay.GetCrossNodeWithOriginTriangle(this.areaTopSideShadowRects[i].TriangleTwo);
if (crossNode2 != null)
{
crossNodes.Add(crossNode2);
}
}
//与态势区域左侧面的交点
Node crossNodeInLeftSide = this.inRay.GetCrossNodeWithAreaQuadrangle(this.areaLeftSideCrossQuad);
if (crossNodeInLeftSide != null)
{
crossNodes.Add(crossNodeInLeftSide);
}
//与态势区域右侧面的交点
Node crossNodeInRightSide = this.inRay.GetCrossNodeWithAreaQuadrangle(this.areaRightSideCrossQuad);
if (crossNodeInRightSide != null)
{
crossNodes.Add(crossNodeInRightSide);
}
//与态势区域前侧面的交点
Node crossNodeInFrontSide = this.inRay.GetCrossNodeWithAreaQuadrangle(this.areaFrontSideCrossQuad);
if (crossNodeInFrontSide != null)
{
crossNodes.Add(crossNodeInFrontSide);
}
//与态势区域后侧面的交点
Node crossNodeInBackSide = this.inRay.GetCrossNodeWithAreaQuadrangle(this.areaBackSideCrossQuad);
if (crossNodeInBackSide != null)
{
crossNodes.Add(crossNodeInBackSide);
}
return(crossNodes);
}
/// <summary>
///获取态势区域所有射线的路径
/// </summary>
/// <param name="currentNode">节点</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="firstN">初始细分点个数</param>
/// <param name="finalN">最终细分点个数</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <returns></returns>
private List <Path> GetAreaPath(Node tx, ReceiveArea reArea, Terrain ter, City cityBuilding, int firstN, int finalN, List <FrequencyBand> txFrequencyBand)
{
List <Path> pathInfo = new List <Path>();
List <RayTracingModel> originUnits = this.GetOriginUnitsOfIcosahedron(tx); //正二十面体的二十个三角面
double finalDivideAngle = this.GetInitialAngleOfRayBeam(finalN); //最终细分角度，弧度制
double firstDivideAngle = this.GetInitialAngleOfRayBeam(firstN); //最初细分角度，弧度制
for (int i = 0; i < originUnits.Count; i++)
{
List <RayTracingModel> firstUnits = this.GetInitialTrianglePath(tx, ter, reArea, cityBuilding, originUnits[i], firstN, firstDivideAngle, txFrequencyBand);
this.GetPathOfUnit(firstUnits, pathInfo, tx, ter, reArea, cityBuilding, finalDivideAngle, txFrequencyBand);
}
return(pathInfo);
}
/// <summary>
///为在态势区域内的路径设置计算节点
/// </summary>
/// <param name="currentNode">节点</param>
/// <returns></returns>
private void SetSpacingNodeInAreaPath(Node tx, ReceiveArea reArea)
{
for (int i = 0; i < this.rayPaths.Count; i++)
{
if (!tx.IsReceiver) //若发射机不在态势区域内
{
int areaCrossNodeNum = 0; //与态势区域交点的个数
for (int j = 1; j < this.rayPaths[i].node.Count - 1; j++)
{
if (this.rayPaths[i].node[j].NodeStyle == NodeStyle.AreaCrossNode)
{
areaCrossNodeNum++;
this.rayPaths[i].node[j].NodeStyle = NodeStyle.Rx;
}
if (areaCrossNodeNum % 2 == 1)
{
List <Node> rxNodes = makeNodesInTheLine(this.rayPaths[i].node[j], this.rayPaths[i].node[j + 1], reArea, reArea.spacing);
this.rayPaths[i].node.InsertRange(j, rxNodes);
j += rxNodes.Count;
}
}
if (this.rayPaths[i].node[this.rayPaths[i].node.Count - 1].NodeStyle == NodeStyle.AreaCrossNode)
{
this.rayPaths[i].node[this.rayPaths[i].node.Count - 1].NodeStyle = NodeStyle.Rx;
}
}
else//若发射机在态势区域内
{
int areaCrossNodeNum = 0;//与态势区域交点的个数
for (int j = 1; j < this.rayPaths[i].node.Count; j++)
{
if (this.rayPaths[i].node[j].NodeStyle == NodeStyle.AreaCrossNode)
{
areaCrossNodeNum++;
this.rayPaths[i].node[j].NodeStyle = NodeStyle.Rx;
}
if (areaCrossNodeNum % 2 == 1 || (areaCrossNodeNum % 2 == 0 && this.rayPaths[i].node[j].NodeStyle != NodeStyle.AreaCrossNode))
{
List <Node> rxNodes = makeNodesInTheLine(this.rayPaths[i].node[j - 1], this.rayPaths[i].node[j], reArea, reArea.spacing);
this.rayPaths[i].node.InsertRange(j, rxNodes);
j += rxNodes.Count;
}
}
}
}
}
/// <summary>
/// 获取所有射线路径
/// </summary>
/// <param name="tx">发射机</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="building">建筑物</param>
/// <param name="firstN">初始细分点个数</param>
/// <returns></returns>
private void GetAreaSituationRxPaths(Node tx, ReceiveArea reArea, Terrain ter, City buildings, int firstN)
{
List <RayTubeModel>[] tubesCrossWithAreaSituation = new List <RayTubeModel> [reArea.areaSituationRect.Count];
for (int i = 0; i < reArea.areaSituationRect.Count; i++)
{
tubesCrossWithAreaSituation[i] = new List <RayTubeModel>(); //初始化
}
List <RayTubeModel> originalUnits = this.GetOriginUnitsOfIcosahedron(); //得到由正二十面体生成的初始的20个射线管模型
for (int i = 11; i < 12; i++)
//for (int i = 19; i < originalUnits.Count; i++)
{
Console.WriteLine("对正二十面体的第{0}个三角面进行射线追踪", i);
Console.Write("起始时间："); Console.Write(DateTime.Now);
Stack <RayTubeModel> initialModels = this.GetInitialRayTubeModels(this.tx, originalUnits[i], firstN); //初始化细分射线管
this.GetRayTubesCrossWithAreaSituation(tubesCrossWithAreaSituation, initialModels, ter, reArea, buildings); //标记与各个态势层相交的射线管
Console.Write(" 完成时间："); Console.Write(DateTime.Now); Console.WriteLine();
}
this.GetPathsFromTxToArea(tubesCrossWithAreaSituation, reArea);
}
/// <summary>
/// 构建态势区域内的Rx节点
/// </summary>
/// <param name="rxNode1">当前节点</param>
/// <param name="rxNode2">下一个节点</param>
/// <param name="reArea">态势区域</param>
/// <param name="distance">与当前节点的距离</param>
/// <returns></returns>
private Node MakeAreaRxNode(Node rxNode1, Node rxNode2, ReceiveArea reArea, double distance)
{
SpectVector vector12 = new SpectVector(rxNode1.Position, rxNode2.Position).GetNormalizationVector();
Point position = new Point(rxNode1.Position.X + distance * vector12.a, rxNode1.Position.Y + distance * vector12.b, rxNode1.Position.Z + distance * vector12.c);
Node rxNode = new Node();
rxNode.Position = position;
rxNode.NodeStyle = NodeStyle.Rx;
rxNode.LayNum = rxNode1.LayNum;
rxNode.DiffractionNum = rxNode1.DiffractionNum;
rxNode.RayIn = rxNode2.RayIn;
rxNode.IsReceiver = true;
rxNode.IsEnd = false;
rxNode.DistanceToFrontNode = distance;
rxNode.RxNum = reArea.RxNum;
rxNode.RayTracingDistance = rxNode1.RayTracingDistance + rxNode.DistanceToFrontNode;
rxNode.NodeName = reArea.RxName;
rxNode.UAN = reArea.UAN;
return(rxNode);
}
/// <summary>
/// 求射线在态势区域上顶面可能经过的矩形
/// </summary>
/// <param name="recArea">接收区域</param>
/// <returns>射线在态势区域上顶面可能经过的矩形list</returns>
private List <Rectangle> GetAreaTopSideShadowRects(ReceiveArea recArea)
{
List <Rectangle> areaBottomSideShadowRects = new List <Rectangle>();
List <Rectangle> areaTopSideShadowRects = new List <Rectangle>();
for (int i = 0; i < this.terShadowRects.Count; i++)//获取射线在接收区域底面可能经过的矩形list
{
//若该矩形在接收区域内
if (this.terShadowRects[i].RectID.FirstID >= recArea.MinRowNum && this.terShadowRects[i].RectID.FirstID <= recArea.MaxRowNum && this.terShadowRects[i].RectID.SecondID >= recArea.MinLineNum && this.terShadowRects[i].RectID.SecondID <= recArea.MaxLineNum)
{
areaBottomSideShadowRects.Add(this.terShadowRects[i]);
}
}
for (int j = 0; j < areaBottomSideShadowRects.Count; j++)//获取射线在接收区域顶面可能经过的矩形list
{
//areaTopSideShadowRects.Add(recArea.TopSideRect[areaBottomSideShadowRects[j].RectID.SecondID - recArea.MinLineNum, areaBottomSideShadowRects[j].RectID.FirstID - recArea.MinRowNum]);
}
return(areaTopSideShadowRects);
}
/// <summary>
///得到正二十面体每个三角形初始细分时的所有射线
/// </summary>
/// <param name="tx">发射机</param>
/// <param name="reArea">态势区域</param>
/// <param name="ter">地形</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <param name="N">三角形处理单元每条边取点个数</param>
/// <param name="divideAngle">射线束夹角</param>
/// <param vertexPoints="N">三角形上用作发射射线的点</param>
/// <returns></returns>
private List <ClassNewRay>[] GetEachTriangleRay(Node tx, Terrain ter, ReceiveArea reArea, City cityBuilding, int N, List <FrequencyBand> txFrequencyBand, List <Point>[] vertexPoints)
{
List <ClassNewRay>[] raysPath = new List <ClassNewRay> [N + 1];
for (int m = 0; m < vertexPoints.Length; m++)
{
raysPath[m] = new List <ClassNewRay>();
for (int n = 0; n < vertexPoints[m].Count; n++)
{
ClassNewRay temp = new ClassNewRay();//每个点发射一条射线，并进行追踪
temp.Origin = tx.Position;
SpectVector paramVector = new SpectVector(vertexPoints[m][n].X, vertexPoints[m][n].Y, vertexPoints[m][n].Z);
RayInfo paramRay = new RayInfo(tx.Position, paramVector);
List <Path> path = this.GetSingleRayPaths(tx, ter, reArea, cityBuilding, paramRay, txFrequencyBand);
temp.Flag = JudgeIfArriveRx(path);
temp.Path = path;
temp.SVector = paramVector;
temp.WhetherHaveTraced = true;
raysPath[m].Add(temp);
}
}
return(raysPath);
}
/// <summary>
///得到与态势区域相交节点,并加入child节点的子节点List中
/// </summary>
/// <param name="fatherNode">父节点</param>
/// <param name="areaNode">与态势区域的交点</param>
/// <param name="reArea">态势区域</param>
/// <returns></returns>
private void SetAreaCrossNode(Node fatherNode, Node areaNode, ReceiveArea reArea)
{
areaNode.LayNum = fatherNode.LayNum;
areaNode.DiffractionNum = fatherNode.DiffractionNum;
areaNode.IsReceiver = true;
areaNode.IsEnd = false;
areaNode.RxNum = reArea.RxNum;
areaNode.RayTracingDistance = fatherNode.RayTracingDistance;
areaNode.RayTracingDistance += areaNode.DistanceToFrontNode;
areaNode.NodeName = reArea.RxName;
areaNode.UAN = reArea.UAN;
//当之前的交点无与态势区域的交点，则把交点放在父节点的childNodes中，若有，则放在之前交点的childNodes中
if (fatherNode.tempNode == null)
{
fatherNode.ChildNodes.Add(areaNode);
fatherNode.tempNode = areaNode;
}
else
{
fatherNode.tempNode.ChildNodes.Add(areaNode);
fatherNode.tempNode = areaNode;
}
}
private ClassNewRay[,] NewInit(Node tx, int cellAngle, Terrain ter, ReceiveArea reArea, List <FrequencyBand> TxFrequencyBand)
{
double radius = 1;
Point target;
SpectVector vector;
int cellTheta = 180 / cellAngle;
int cellPhi = 360 / cellAngle;
ClassNewRay[,] initNewRay = new ClassNewRay[cellPhi, cellTheta];
for (int i = 0; i < cellPhi; i++)
{
for (int j = 0; j < cellTheta; j++)
{
target = new Point(radius * Math.Sin(Math.PI / 180 * j * cellAngle) * Math.Cos(Math.PI / 180 * i * cellAngle), radius * Math.Sin(Math.PI / 180 * j * cellAngle) * Math.Sin(Math.PI / 180 * i * cellAngle), radius * Math.Cos(Math.PI / 180 * j * cellAngle));
vector = new SpectVector(target.X, target.Y, target.Z);
List <RayInfo> list1 = new List <RayInfo>();
list1.Add(new RayInfo(tx.Position, vector));
List <Path> pathtemp = GetFanalPath(tx, ter, reArea, TxFrequencyBand, list1);
initNewRay[i, j] = new ClassNewRay(tx.Position, vector, Ismeat(pathtemp), pathtemp);
}
}
return(initNewRay);
}
private void Port_DataRecevied(object sender, SerialDataReceivedEventArgs e)
{
//串口接收事件
if (!PutIntoFile.Checked)
{
if (!Hexshow.Checked)
{
string str = serialPort1.ReadExisting();
ReceiveArea.AppendText(str);
//正常接收
}
else
{
byte data;
data = (byte)serialPort1.ReadByte();
string datareceive = Convert.ToString(data, 16).ToUpper();
ReceiveArea.AppendText("0x" + (datareceive.Length == 1 ? "0" + datareceive : " "));
//十六进制接收，分开，填“0x”
}
}
else
{
//接收到文件，方式同上
if (!Hexshow.Checked)
{
string datareceive = serialPort1.ReadExisting();
File.AppendAllText(SaveFilePath.Text, datareceive);
}
else
{
byte data;
data = (byte)serialPort1.ReadByte();
string datareceive = Convert.ToString(data, 16).ToUpper();
File.AppendAllText(SaveFilePath.Text, "0x" + (datareceive.Length == 1 ? "0" + datareceive : " "));
}
}
}
/// <summary>
///态势区域时的追踪方法
/// </summary>
/// <param name="currentNode">节点</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <returns></returns>
public void SetAreaRayPathNodes(Node currentNode, Terrain ter, ReceiveArea reArea, City cityBuilding, List <FrequencyBand> txFrequencyBand)
{
//求交点
List <Node> crossNodes = GetCrossPointsWithEnvironment(reArea, cityBuilding, txFrequencyBand, 30);
if (crossNodes.Count == 0)//若射线与各个物体都没有交点,设为停止节点
{
if (currentNode.NodeStyle != NodeStyle.Tx)
{
currentNode.IsEnd = true;
}
return;
}
else
{
for (int i = 0; i < crossNodes.Count; i++)
{
if (crossNodes[i].NodeStyle == NodeStyle.ReflectionNode)//若为反射点
{
this.SetReflectionNode(currentNode, crossNodes[i], ter, cityBuilding, reArea, txFrequencyBand);
break;
}
else if (crossNodes[i].NodeStyle == NodeStyle.CylinderCrossNode)//若为绕射点,追踪绕射绕射，并继续追踪下一个点
{
this.SetDiffractionNode(currentNode, crossNodes[i], ter, cityBuilding, reArea, txFrequencyBand);
}
else //若为与态势区域的交点
{
this.SetAreaCrossNode(currentNode, crossNodes[i], reArea);
if (crossNodes.Count == 1)
{
crossNodes[i].IsEnd = true;
}
}
}
}
}
/// <summary>
/// 获得从发射点到态势区域的路径
/// </summary>
/// <param name="tubesCrossWithAreaSituation">到达各个态势层的射线管集合</param>
/// <param name="reArea">态势区域</param>
private void GetPathsFromTxToArea(List <RayTubeModel>[] tubesCrossWithAreaSituation, ReceiveArea reArea)
{
for (int i = 0; i < reArea.areaSituationRect.Count; i++)//按照态势层循环
{
Console.Write("正在处理第{0}个态势层,起始时间：", i); Console.Write(DateTime.Now);
int rowDiscretedNum = 7; //行离散倍数，可更改
int lineDiscretedNum = 6; //列离散倍数，可更改
List <AreaNode> areaSituationNodes = new List <AreaNode>();
//将当前态势层离散为态势点
areaSituationNodes.AddRange(this.GetAreaNodesByDiscretedNum(reArea.areaSituationRect[i], rowDiscretedNum, lineDiscretedNum));
//遍历与当前态势层对应的射线管
foreach (RayTubeModel currentRayTube in tubesCrossWithAreaSituation[i])
{
List <Node> pathNodes = new List <Node>();//存储从发射节点到当前射线管的发射节点所经过的路径节点
//得到从发射点到当前射线管的list<node>
this.GetFrontNodesOfAreaSituationNodes(currentRayTube, pathNodes);
//可改进：遍历态势点，得到当前射线管包含的态势点并得出完整路径
for (int m = 0; m < areaSituationNodes.Count; m++)
{
//如果射线管经过此态势点，就会将从发射点到态势点的路径加至态势点的paths属性中
this.GetAreaNodeIfRayTubeContainPoint(currentRayTube, areaSituationNodes[m], pathNodes);//判断射线管是否到达虚拟接收点
}
}
reArea.areaSituationNodes.AddRange(areaSituationNodes);
//reArea.areaSituationNodes.AddRange(((List<AreaNode>areaSituationNodes.clone())));
Console.Write("完成时间："); Console.Write(DateTime.Now); Console.WriteLine();
}
}
/// <summary>
///得到DiffractionPoint节点,并加入child节点的子节点List中
/// </summary>
/// <param name="fatherNode">父节点</param>
/// <param name="cylinderCrossNode">绕射相交点</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <returns></returns>
private void SetDiffractionNode(Node fatherNode, Node cylinderCrossNode, Terrain ter, City cityBuilding, ReceiveArea reArea, List <FrequencyBand> txFrequencyBand)
{
Node diffractionNode = new Node();
diffractionNode.Position = cylinderCrossNode.DiffractionEdge.GetPedalPoint(cylinderCrossNode.Position);
//若求出的绕射点位置在绕射棱外部或者与绕射棱两个端点重合
if (!cylinderCrossNode.DiffractionEdge.JudgeIfPointInLineRange(diffractionNode.Position) ||
diffractionNode.Position.equal(cylinderCrossNode.DiffractionEdge.StartPoint) ||
diffractionNode.Position.equal(cylinderCrossNode.DiffractionEdge.EndPoint))
{
return;
}
else
{
diffractionNode.DiffractionEdge = cylinderCrossNode.DiffractionEdge;
diffractionNode.DisranceToEdge = cylinderCrossNode.DisranceToEdge;
diffractionNode.NodeStyle = NodeStyle.DiffractionNode;
diffractionNode.LayNum = fatherNode.LayNum;
diffractionNode.DiffractionNum = fatherNode.DiffractionNum + 1;
diffractionNode.IsReceiver = false;
diffractionNode.UAN = reArea.UAN;
diffractionNode.DistanceToFrontNode = diffractionNode.Position.GetDistance(fatherNode.Position);
diffractionNode.RayTracingDistance = fatherNode.RayTracingDistance;
diffractionNode.RayTracingDistance += diffractionNode.DistanceToFrontNode;
diffractionNode.RayIn = new RayInfo(fatherNode.Position, diffractionNode.Position);
if (fatherNode.tempNode == null)
{
fatherNode.ChildNodes.Add(diffractionNode);
}
else
{
// diffractionNode.DistanceToFrontNode = diffractionNode.Position.GetDistance(fatherNode.tempNode.Position);
fatherNode.tempNode.ChildNodes.Add(diffractionNode);
}
// diffractionNode.JudgeIfNodeIsInArea(ter,reArea);
//当新节点的层数加绕射次数不小于4或者绕射次数大于2，说明该路径已经过三次反射（或两次反射一次绕射）或者两次绕射，舍弃并追踪下一条射线,并将该节点设为end
//但是当该节点在态势区域内时，则继续追踪
if (((diffractionNode.DiffractionNum >= 2) || ((diffractionNode.LayNum + diffractionNode.DiffractionNum) >= 4)) && !diffractionNode.IsReceiver)
{
diffractionNode.IsEnd = true;
}
//否则继续追踪射线
else
{
diffractionNode.IsEnd = false;
List <RayInfo> DiffractionRays = Rays.GetDiffractionRays(fatherNode.Position, diffractionNode.Position, diffractionNode.DiffractionEdge, 12);
for (int i = 0; i < DiffractionRays.Count; i++)
{
//AreaPath areaPath = new AreaPath(DiffractionRays[i], ter, reArea);
//areaPath.SetAreaRayPathNodes(diffractionNode, ter, reArea, cityBuilding, txFrequencyBand);
}
}
}
}
/// <summary>
///返回接收球，如果是区域状则返回多个接收球
/// </summary>
public static List <List <ReceiveBall> > GetRx(string rxpath, string setup, string terpath)
{
List <List <ReceiveBall> > RxBalls = new List <List <ReceiveBall> >();
List <RxObject> Rx = RxReader(rxpath);
for (int i = 0; i < Rx.Count; i++)
{
//这是点状和区域状
if (Rx[i].flag != "<situation>")
{
if (Rx[i].flag.Equals("<points>"))
{
Point lc = new Point(Rx[i].Lc.vertical[0], Rx[i].Lc.vertical[1], Rx[i].Lc.vertical[2]);
//GetZValue(ter, lc);
lc.Z = Rx[i].Lc.vertical[2] + Rx[i].cubesize;
List <ReceiveBall> temp = new List <ReceiveBall>();
ReceiveBall rxtemp = new ReceiveBall(lc, Rx[i].num, Rx[i].name);
rxtemp.UAN = ReadUan.GetUan(Rx[i], SetupFileProceed.GetSetupFile.GetSetup(setup));
temp.Add(rxtemp);
RxBalls.Add(temp);
}
else //现在不会进入这个分支
{
List <ReceiveBall> temp = new List <ReceiveBall>();
double length = (double)Rx[i].Lc.side1;
double width = (double)Rx[i].Lc.side2;
double space = (double)Rx[i].Lc.spacing;
for (int j = 0; j < width / space + 1; j++)
{
for (int k = 0; k < length / space + 1; k++)
{
Point lc = new Point(Rx[i].Lc.vertical[0] + k * space, Rx[i].Lc.vertical[1] - j * space, Rx[i].Lc.vertical[2]);
//GetZValue(ter, lc);
lc.Z += Rx[i].Lc.vertical[2] + Rx[i].cubesize;
ReceiveBall rxtemp = new ReceiveBall(lc, Rx[i].num, Rx[i].name);
rxtemp.UAN = ReadUan.GetUan(Rx[i], SetupFileProceed.GetSetupFile.GetSetup(setup));
temp.Add(new ReceiveBall(lc, Rx[i].num, Rx[i].name));
}
}
RxBalls.Add(temp);
}
}
//这是态势显示
else
{
if ((double)Rx[i].Lc.side1 == 0 || (double)Rx[i].Lc.side2 == 0)//态势区域边长不能为0
{
LogFileManager.ObjLog.debug("态势区域边长为0，出错");
}
// Rx[i].Lc.spacing = 50;
// Spacing = (double)Rx[i].Lc.spacing;
List <ReceiveBall> temp = new List <ReceiveBall>();
ReceiveBall receiveArea = new ReceiveArea();
receiveArea.UAN = ReadUan.GetUan(Rx[i], SetupFileProceed.GetSetupFile.GetSetup(setup));
Point lc = new Point(Rx[i].Lc.vertical[0], Rx[i].Lc.vertical[1], Rx[i].Lc.vertical[2]);
receiveArea.temp = Rx[i].Lc.vertical[2];
//GetZValue(ter, lc);
lc.Z = Rx[i].Lc.vertical[2] + Rx[i].cubesize;
//receiveArea.rxLength = (double)Rx[i].Lc.side1;
//receiveArea.rxWidth = (double)Rx[i].Lc.side2;
//receiveArea.spacing =(double)Rx[i].Lc.spacing;
//receiveArea.origen = lc;
receiveArea.Instance((double)Rx[i].Lc.side1, (double)Rx[i].Lc.side2, (double)Rx[i].Lc.spacing, lc);
receiveArea.RxName = Rx[i].name;
receiveArea.RxNum = Rx[i].num;
temp.Add(receiveArea);
RxBalls.Add(temp);
}
}
return(RxBalls);
}
/// <summary>
///得到ReflectionPoint节点,并加入child节点的子节点List中
/// </summary>
/// <param name="fatherNode">父节点</param>
/// <param name="reNode">反射点</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="cityBuilding">建筑物</param>
/// <param name="TxFrequencyBand">发射机频段信息</param>
/// <returns></returns>
private void SetReflectionNode(Node fatherNode, Node reNode, Terrain ter, City cityBuilding, ReceiveArea reArea, List <FrequencyBand> txFrequencyBand)
{
reNode.LayNum = fatherNode.LayNum + 1;
reNode.DiffractionNum = fatherNode.DiffractionNum;
reNode.IsReceiver = false;
reNode.UAN = reArea.UAN;
reNode.RayTracingDistance = fatherNode.RayTracingDistance;
reNode.RayIn = new RayInfo(fatherNode.Position, reNode.Position);
reNode.RayTracingDistance += reNode.DistanceToFrontNode;
if (fatherNode.tempNode == null)
{
fatherNode.ChildNodes.Add(reNode);
}
else
{
// reNode.DistanceToFrontNode = reNode.Position.GetDistance(fatherNode.tempNode.Position);
fatherNode.tempNode.ChildNodes.Add(reNode);
}
// reNode.JudgeIfNodeIsInArea(ter,reArea);
//当新节点的层数加绕射次数不小于4或者绕射次数大于2，说明该路径已经过三次反射（或两次反射一次绕射）或者两次绕射，舍弃并追踪下一条射线,并将该节点设为end
//但是当该节点在态势区域内时，则继续追踪
if (((reNode.DiffractionNum >= 2) || ((reNode.LayNum + reNode.DiffractionNum) >= 4)) && !reNode.IsReceiver)
{
reNode.IsEnd = true;
// reNode.NodeStyle = NodeStyle.FinalNode;
}
//否则，递归调用该函数继续追踪射线
else
{
reNode.IsEnd = false;
RayInfo reflectionRay = reNode.RayIn.GetReflectionRay(reNode.ReflectionFace, reNode.Position);
//AreaPath areaPath = new AreaPath(reflectionRay, ter, reArea);
//areaPath.SetAreaRayPathNodes(reNode, ter, reArea, cityBuilding, txFrequencyBand);
}
}
public static void OutPathArea(List <CalculateModelClasses.Path> Paths, string sPath, string projectName, int txIndex, int txTotol, ReceiveArea rArea, Terrain ter, ref Dictionary <int, List <Plural> > projectionResult, int Frequence, int minFrequence, int maxFrequence)
{
string Rxname = Paths[0].node[Paths[0].node.Count - 1].NodeName;
Console.WriteLine(sPath + projectName + "_power" + "_t00" + txIndex + "_0" + txTotol + ".p2m");
FileStream fs = new FileStream(sPath + projectName + "_" + "situation" + "_power" + "_t00" + txIndex + "_0" + txTotol + "_" + Frequence.ToString("D4") + "_" + minFrequence.ToString("D4") + "_" + maxFrequence.ToString("D4") + ".p2m", FileMode.Create);//如果是接收区域的话，多个接收点组成一组接收机组成一个编号
StreamWriter sw = new StreamWriter(fs);
List <int> rxCounter = AreaUtils.getCount4Rx(rArea);
int Rxnum = rxCounter[0] * rxCounter[1];
sb.AppendLine("# Receiver Set:" + Rxname);
sb.AppendLine("# Rx# X(m) Y(m) Z(m) Distance (m) Power (dBm) Phase (Deg.)");
List <CalculateModelClasses.Path> omg = AreaUtils.getPaths(Paths);
projectionResult = AreaUtils.yingshe(rxCounter, omg, rArea);
double temp = rArea.temp;
foreach (var item in projectionResult.Keys)
{
Point receiverPoint = AreaUtils.GetCenterPointInAreaDivision(rArea, rxCounter, ter, item, temp);
double distance = Paths[0].node[0].Position.GetDistance(receiverPoint);
Plural tempPower = projectionResult[item][0];
double angle = Math.Atan(tempPower.Im / tempPower.Re) * 180 / Math.PI;
if (angle < 0)
{
angle = angle + 180;
}
if (tempPower.Re == 0 && tempPower.Im == 0)
{
sb.AppendLine(AreaUtils.getBlank(item, 6) + item + " " + receiverPoint.X.ToString("E7") + " " + receiverPoint.Y.ToString("E7") + " " + receiverPoint.Z.ToString("f3") + " " + distance.ToString("f2") + " " + "-100.00" + " " + "0.00");
}
else
{
double powerMag = (10 * Math.Log10(Math.Sqrt(Math.Pow(tempPower.Re, 2) + Math.Pow(tempPower.Im, 2)))) + 30;
//string test = AreaUtils.getBlank((int)Math.Floor(powerMag), 11);
//AreaUtils.getBlank((int)Math.Floor(angle), 11);
//string test2 = AreaUtils.getBlank(int.Parse(angle.ToString()), 11);
sb.AppendLine(AreaUtils.getBlank(item, 6) + item + " " + receiverPoint.X.ToString("E7") + " " + receiverPoint.Y.ToString("E7") + " " + receiverPoint.Z.ToString("f3") + " " + distance.ToString("f2") + AreaUtils.getBlank((int)Math.Floor(powerMag), 11) + powerMag.ToString("f2") + AreaUtils.getBlank((int)Math.Floor(angle), 11) + angle.ToString("f2"));
}
}
sw.Write(sb);
sb.Clear();
sw.Close();
fs.Close();
}
public static void p2mfileoutputArea(List <CalculateModelClasses.Path> Paths, string filePath, string ProjName, int TxIndex, int txTotol, ReceiveArea rArea, Terrain ter, int index, int Frequence, int minFrequence, int maxFrequence)
{
if (maxFrequence > 9999)
{
throw new Exception("频率过大");
}
lock (typeof(P2mFileOutput))
{
if (index == 0)
{
if (!Directory.Exists(filePath))
{
//DeleteDir(filePath);
//Directory.Delete(filePath);
Directory.CreateDirectory(filePath);
}
//Directory.CreateDirectory(filePath);
}
if (Paths.Count != 0)
{
Dictionary <int, List <Plural> > projectionResult = null;
OutputDelegateArea output = PowerOutput.OutPathArea;
output += ErmOutput.OutPathArea;
output(Paths, filePath, ProjName, TxIndex, txTotol, rArea, ter, ref projectionResult, Frequence, minFrequence, maxFrequence);
projectionResult.Clear();
GC.Collect();
}
else
{
OutputDelegate1 output1 = PowerOutput.OutPath1;
output1 += ErmOutput.OutPath1;
output1(Paths, filePath);
}
}
}
/// <summary>
///对一个射线管进行处理
/// </summary>
/// <param name="paramModel">射线管</param>
/// <param name="rayTubeModels">射线管的栈</param>
/// <returns></returns>
private void HandleTheRayTubeModel(RayTubeModel paramModel, Stack <RayTubeModel> rayTubeModels, ReceiveArea reArea, List <RayTubeModel>[] newRayTubes,
double lengthX, double lengthY)
{
if (paramModel.JudgeIfThisModelNeedToBeDivided())//判断射线管是否需要进行细分
{
int divisionNum = paramModel.GetDivisionNumOfLine(lengthX, lengthY);
List <RayTubeModel> newModels = paramModel.GetDivisionRayTubeModels(divisionNum);//细分后的射线管模型，将细分后的射线管压入栈中
for (int i = 0; i < newModels.Count; i++)
{
rayTubeModels.Push(newModels[i]);//加入栈中
}
}
else//射线管不需要细分
{
//进入此环节的射线管已经完成了与地面和建筑物的求交计算，并且射线管不需要再细分
//判断射线管有没有到达态势区域
paramModel.UpdateAreaSituationFlag(reArea); //判断射线管有没有到达态势区域
if (paramModel.IsReachingArea) //若射线管到达态势区域
{
for (int i = 0; i < paramModel.crossLayerNum.Count; i++) //依次读取当前射线管中crossLayerNum的信息
{
int num = paramModel.crossLayerNum[i];
newRayTubes[num].Add((RayTubeModel)paramModel.Clone());//将射线管添加到对应的newRayTubes中
}
}
if (paramModel.ReflectionTracingTimes + paramModel.DiffractionTracingTimes >= 4 ||
paramModel.DiffractionTracingTimes >= 2) //判断射线管是否满足截止条件
{
return;
}
else//获取射线管下一阶段的射线管模型
{
List <RayTubeModel> nextModels = paramModel.GetNextRayTubeModels();//下一阶段射线管模型
for (int i = 0; i < nextModels.Count; i++)
{
rayTubeModels.Push(nextModels[i]);//加入栈中
}
}
}
}
/// <summary>
/// 获取与态势相交的射线管
/// </summary>
/// <param name="rayTubeModels">存放射线管的栈</param>
/// <param name="ter">地形</param>
/// <param name="reArea">态势区域</param>
/// <param name="buildings">建筑物</param>
/// <returns>按态势层的次序存放与态势层相交的射线管</returns>
private void GetRayTubesCrossWithAreaSituation(List <RayTubeModel>[] tubesCrossWithAreaSituation, Stack <RayTubeModel> rayTubeModels, Terrain ter, ReceiveArea reArea, City buildings)
{
if (rayTubeModels == null || rayTubeModels.Count == 0)
{
LogFileManager.ObjLog.error("在追踪处理射线管模型时，输入参数为0或者空");
}
double lengthX = ter.MaxX - ter.MinX;
double lengthY = ter.MaxY - ter.MinY;
while (rayTubeModels.Count != 0)
{
RayTubeModel paramModel = rayTubeModels.Pop(); //从栈中抛出一个射线管进行处理
if (!paramModel.HaveTraced) //判断射线管是否已完成与地形，建筑物的求交计算过程
{
paramModel.TracingThisRayTubeModel(ter, buildings); //进行射线求交
}
//对射线管进行处理,包括是否细分、是否到达态势区域、是否满足截止条件
this.HandleTheRayTubeModel(paramModel, rayTubeModels, reArea, tubesCrossWithAreaSituation, lengthX, lengthY);
}
}
public static void GetAreaTotalPower(List <CalculateModelClasses.Path> Paths, string sPath, string projectName, int txIndex, int txTotol, ReceiveArea rArea, Terrain ter)
{
if (Paths.Count != 0)
{
string Rxname = Paths[0].node[Paths[0].node.Count - 1].NodeName;
Console.WriteLine(sPath + projectName + "_power" + "_t00" + txIndex + "_0" + txTotol + ".p2m");
FileStream fs = new FileStream(sPath + projectName + "_" + "situation" + "_power" + "_total" + "_" + "t00" + txIndex + "_0" + txTotol + ".p2m", FileMode.Create);//如果是接收区域的话，多个接收点组成一组接收机组成一个编号
StreamWriter sw = new StreamWriter(fs);
List <int> rxCounter = AreaUtils.getCount4Rx(rArea);
int Rxnum = rxCounter[0] * rxCounter[1];
sb.AppendLine("# Receiver Set:" + Rxname);
sb.AppendLine("# Rx# X(m) Y(m) Z(m) Distance (m) Power (dBm) Phase (Deg.)");
List <CalculateModelClasses.Path> omg = AreaUtils.getPaths(Paths);
Console.WriteLine("Power begin" + System.DateTime.Now);
Dictionary <int, List <Plural> > projectionResult = AreaUtils.yingshe(rxCounter, omg, rArea);
Console.WriteLine("Power finish" + System.DateTime.Now);
double temp = rArea.temp;
foreach (var item in projectionResult.Keys)
{
Point receiverPoint = AreaUtils.GetCenterPointInAreaDivision(rArea, rxCounter, ter, item, temp);
double distance = Paths[0].node[0].Position.GetDistance(receiverPoint);
Plural tempPower = projectionResult[item][0];
//角度计算，从局域信息中读取
double angle = projectionResult[item][4].Re;
if (tempPower.Re == 0 && tempPower.Im == 0)
{
sb.AppendLine(AreaUtils.getBlank(item, 6) + item + " " + receiverPoint.X.ToString("E7") + " " + receiverPoint.Y.ToString("E7") + " " + receiverPoint.Z.ToString("f3") + " " + distance.ToString("f2") + " " + "-100.00" + " " + "0.00");
}
else
{
double powerMag = (10 * Math.Log10(tempPower.Re)) + 30;
//string test = AreaUtils.getBlank((int)Math.Floor(powerMag), 11);
//AreaUtils.getBlank((int)Math.Floor(angle), 11);
//string test2 = AreaUtils.getBlank(int.Parse(angle.ToString()), 11);
sb.AppendLine(AreaUtils.getBlank(item, 6) + item + " " + receiverPoint.X.ToString("E7") + " " + receiverPoint.Y.ToString("E7") + " " + receiverPoint.Z.ToString("f3") + " " + distance.ToString("f2") + AreaUtils.getBlank((int)Math.Floor(powerMag), 11) + powerMag.ToString("f2") + AreaUtils.getBlank((int)Math.Floor(angle), 11) + angle.ToString("f2"));
}
}
projectionResult.Clear();
sw.Write(sb);
sb.Clear();
sw.Close();
fs.Close();
}
else
{
FileStream fs = new FileStream(sPath + "t00" + txIndex + "_0" + txTotol + "TotalPowerOutputNull.p2m", FileMode.Append);
StreamWriter sw = new StreamWriter(fs);
sw.Close();
fs.Close();
}
}
//态势接收
public RayTubeMethod(Node tx, ReceiveArea reArea, Terrain ter, City buildings, int firstN)
{
this.tx = tx;
this.GetAreaSituationRxPaths(tx, reArea, ter, buildings, firstN);
}
