示例#1
0
        /// <summary>
        /// 从PlanCourse取出一个当前累积权值最小,并且没有被处理过的节点
        /// </summary>
        /// <returns></returns>
        private Node GetMinWeightRudeNode(PlanCourse planCourse, List <Node> nodeList, string originID)
        {
            double weight   = double.MaxValue;
            Node   destNode = null;

            foreach (Node node in nodeList)
            {
                if (node.ID == originID)
                {
                    continue;
                }

                PassedPath pPath = planCourse[node.ID];
                if (pPath.BeProcessed)
                {
                    continue;
                }

                if (pPath.Weight < weight)
                {
                    weight   = pPath.Weight;
                    destNode = node;
                }
            }

            return(destNode);
        }
示例#2
0
        //获取权值最小的路径
        public RoutePlanResult Paln(List <Node> nodeList, string originID, string destID)
        {
            //初始化起始节点到其他节点的路径表(权值,经过的节点,是否被处理)
            //同时初始化其他节点的路径表
            PlanCourse planCourse = new PlanCourse(nodeList, originID);

            Node curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);

            #region 计算过程
            while (curNode != null)
            {
                PassedPath curPath = planCourse[curNode.ID];
                foreach (Edge edge in curNode.EdgeList)
                {
                    if (edge.EndNodeID == originID)
                    {
                        continue;
                    }

                    PassedPath targetPath = planCourse[edge.EndNodeID];
                    double     tempWeight = curPath.Weight + edge.Weight;

                    if (tempWeight < targetPath.Weight)
                    {
                        targetPath.Weight = tempWeight;
                        targetPath.PassedIDList.Clear();

                        for (int i = 0; i < curPath.PassedIDList.Count; i++)
                        {
                            targetPath.PassedIDList.Add(curPath.PassedIDList[i].ToString());
                            targetPath.PassedPointList.Add(curPath.PassedPointList[i]);
                        }

                        targetPath.PassedIDList.Add(curNode.ID);
                        targetPath.PassedPointList.Add(curNode.Point);
                    }
                }

                //标志为已处理
                planCourse[curNode.ID].BeProcessed = true;
                //获取下一个未处理节点
                curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);
            }
            #endregion

            //表示规划结束
            return(this.GetResult(planCourse, destID));
        }
示例#3
0
        /// <summary>
        /// 从PlanCourse表中取出目标节点的PassedPath,这个PassedPath即是规划结果
        /// </summary>
        /// <returns></returns>
        private RoutePlanResult GetResult(PlanCourse planCourse, string destID)
        {
            PassedPath pPath = planCourse[destID];

            if (pPath.Weight == int.MaxValue)
            {
                RoutePlanResult result1 = new RoutePlanResult(null, int.MaxValue, null);
                return(result1);
            }

            string[]     passedNodeIDs   = new string[pPath.PassedIDList.Count];
            List <Point> passedlistPoint = new List <Point>();

            for (int i = 0; i < passedNodeIDs.Length; i++)
            {
                passedNodeIDs[i] = pPath.PassedIDList[i].ToString();
                passedlistPoint.Add(pPath.PassedPointList[i]);
            }

            RoutePlanResult result = new RoutePlanResult(passedNodeIDs, pPath.Weight, passedlistPoint);

            return(result);
        }