Revit二次开发小技巧（十六）寻找最短路径

已于 2023-01-09 09:19:03 修改
阅读量996 收藏 15
点赞数 4
分类专栏： Revit二次开发小技巧 文章标签： c# 经验分享
于 2022-12-29 00:24:17 首次发布
包包熊出品
本文链接：https://blog.csdn.net/Oneal5354/article/details/128475278
版权

最近遇到一个需求，指定两个配电箱，然后找到两个配电箱之间最短的桥架路径。运用了Dijkstra算法去计算最短路径，以配电箱实体、三通、四通为节点，简化中间弯头计算的方式。

背景

在这里插入图片描述
选择起点和终点的配电箱，找到最短的桥架路径
在这里插入图片描述

代码文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autodesk.Revit.Attributes;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using Autodesk.Revit.UI.Selection;


namespace RevitTest.Short
{
    [Transaction(TransactionMode.Manual)]
    public class ShortCmd : IExternalCommand
    {
        /// <summary>
        /// 所有结点集合
        /// </summary>
        List<NodeModel> _allNodelModelList = new List<NodeModel>();
        /// <summary>
        /// 所有结点连接集合
        /// </summary>
        List<NodeLink> _allNodeLinkList = new List<NodeLink>();
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIDocument uidoc = commandData.Application.ActiveUIDocument;
            Document doc = uidoc.Document;
            Reference selOneRef = null;
            Reference selTwoRef = null;
            try
            {
                selOneRef = uidoc.Selection.PickObject(ObjectType.Element, "选择起始配电箱");
                selTwoRef = uidoc.Selection.PickObject(ObjectType.Element, "选择终点配电箱");
            }
            catch
            {
            }
            FamilyInstance targetFI = doc.GetElement(selOneRef) as FamilyInstance;
            FamilyInstance endFI = doc.GetElement(selTwoRef) as FamilyInstance;
            NodeInit(doc, targetFI);
            //先构造所有的点数据
            List<NodeLink> shortNLList = new List<NodeLink>();
            for (int i = 0; i < _allNodelModelList.Count; i++)
            {
                NodeLink nwLink = new NodeLink();
                nwLink.OneModel = _allNodelModelList[0];
                nwLink.TwoModel = _allNodelModelList[i];
                if (i == 0) nwLink.LinkLenght = 0;
                else nwLink.LinkLenght = double.MaxValue;
                shortNLList.Add(nwLink);
            }
            while (true)
            {
                //如果终点给标记的时候就弹出了
                if (shortNLList.FirstOrDefault(x => x.TwoModel.Equals(endFI)).IsTag == true) break;
                NodeLink oneLink = shortNLList.Where(x => !x.IsTag).OrderBy(x => x.LinkLenght).FirstOrDefault();
                if (oneLink == null) break;
                List<NodeLink> linkList = _allNodeLinkList.FindAll(x => x.OneModel.Equals(oneLink.TwoModel) || x.TwoModel.Equals(oneLink.TwoModel));
                foreach (var nl in linkList)
                {
                    double lenght = nl.LinkLenght + oneLink.LinkLenght;
                    NodeModel orderNM = nl.OneModel.Equals(oneLink.TwoModel) ? nl.TwoModel : nl.OneModel;
                    NodeLink orderNL = shortNLList.FirstOrDefault(x => x.TwoModel.Equals(orderNM));
                    if (lenght < orderNL.LinkLenght)
                    {
                        orderNL.LinkLenght = lenght;
                        orderNL.LinkMEPCurveList = new List<MEPCurve>();
                        orderNL.LinkMEPCurveList.AddRange(oneLink.LinkMEPCurveList);
                        orderNL.LinkMEPCurveList.AddRange(nl.LinkMEPCurveList);
                    }
                }
                oneLink.IsTag = true;
            }
            NodeLink findNL = shortNLList.FirstOrDefault(x => x.TwoModel.Equals(endFI));
            uidoc.Selection.SetElementIds(findNL.LinkMEPCurveList.Select(x => x.Id).ToList());


            return Result.Succeeded;
        }
        /// <summary>
        /// 结点数据初始化
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="targetFI"></param>
        public void NodeInit(Document doc, FamilyInstance targetFI)
        {
            NodeModel nm = new NodeModel(targetFI);
            if (_allNodelModelList.FirstOrDefault(x => x.Equals(nm)) != null) return;
            //拿到已经连接的连接器
            List<Connector> connList = targetFI.MEPModel.ConnectorManager.Connectors.OfType<Connector>().Where(x => x.IsConnected && x.AllRefs.Cast<Connector>().FirstOrDefault(m => m.Owner.Id == targetFI.Id) == null).ToList();
            nm.ConnectorList = connList;
            _allNodelModelList.Add(nm);
            while (true)
            {
                NodeModel oneNM = _allNodelModelList.FirstOrDefault(x => x.ConnectorList.Count != 0);
                if (oneNM == null) break;
                for (int i = 0; i < oneNM.ConnectorList.Count; i++)
                {
                    Connector con = oneNM.ConnectorList[i];
                    List<MEPCurve> mepCurveList = new List<MEPCurve>();
                    FamilyInstance nodeFI = null;
                    ElementId endElementID = null;
                    //找到对应连接的连接件
                    List<Connector> linkConList = con.AllRefs.Cast<Connector>().Where(x => x.Owner.Id != con.Owner.Id).ToList();
                    //添加连接到的构件
                    var linkElement = doc.GetElement(linkConList.FirstOrDefault().Owner.Id);
                    if (linkElement is FamilyInstance)
                    {
                        mepCurveList.AddRange(GetLinkMepCurveList(linkElement as FamilyInstance, oneNM.NodeFamilyInstance.Id, out nodeFI, out endElementID));
                    }
                    else
                    {
                        mepCurveList.AddRange(GetLinkMepCurveList(linkElement as MEPCurve, oneNM.NodeFamilyInstance.Id, out nodeFI, out endElementID));
                    }

                    #region 计算长度
                    double mepLenght = 0;
                    foreach (var item in mepCurveList)
                    {
                        try
                        {
                            mepLenght += (item.Location as LocationCurve).Curve.Length;
                        }
                        catch
                        {
                        }
                    }
                    #endregion
                    NodeLink nodeLink = new NodeLink();
                    nodeLink.OneModel = oneNM;
                    nodeLink.TwoModel = null;
                    nodeLink.LinkMEPCurveList = mepCurveList;
                    nodeLink.LinkLenght = mepLenght;
                    if (nodeFI != null)
                    {
                        NodeModel nextNM = _allNodelModelList.FirstOrDefault(x => x.Equals(nodeFI));
                        if (nextNM == null)
                        {
                            nextNM = new NodeModel(nodeFI);
                            //拿到所有构件的连接件
                            nextNM.ConnectorList = nodeFI.MEPModel.ConnectorManager.Connectors.Cast<Connector>().Where(x => x.IsConnected).ToList();
                            _allNodelModelList.Add(nextNM);
                        }
                        nodeLink.TwoModel = nextNM;
                        //处理终点的连接器
                        Connector nextEndConn = nextNM.ConnectorList.FirstOrDefault(x => x.AllRefs.OfType<Connector>().FirstOrDefault(m => m.Owner.Id == endElementID) != null);
                        nextNM.ConnectorList.Remove(nextEndConn);
                        nextNM.UserConnectIndexDic.Add(nextEndConn, _allNodeLinkList.Count - 1);
                        //处理起始结点的连接器
                        _allNodeLinkList.Add(nodeLink);
                        oneNM.UserConnectIndexDic.Add(con, _allNodeLinkList.Count - 1);
                    }
                    oneNM.ConnectorList.RemoveAt(i);
                    i--;
                }
            }
        }
        /// <summary>
        /// 计算单条机电线管设备的完整路径
        /// </summary>
        /// <param name="mepCurve"></param>
        /// <param name="linkId"></param>
        /// <param name="fi"></param>
        /// <param name="endConnMCID"></param>
        /// <returns></returns>
        public List<MEPCurve> GetLinkMepCurveList(MEPCurve mepCurve, ElementId linkId, out FamilyInstance fi, out ElementId endConnMCID)
        {
            List<MEPCurve> mepCurveList = new List<MEPCurve> { mepCurve };
            //拿到两端连接件
            List<Connector> connertorList = mepCurve.ConnectorManager.Connectors.Cast<Connector>().Where(x => x.IsConnected && x.AllRefs.Cast<Connector>().FirstOrDefault(m => m.Owner.Id == linkId) == null).ToList();
            Connector con = connertorList.FirstOrDefault();
            if (con == null)
            {
                fi = null;
                endConnMCID = null;
                return mepCurveList;
            }
            //找到对应连接的连接件
            List<Connector> linkConList = con.AllRefs.Cast<Connector>().Where(x => x.Owner.Id != con.Owner.Id).ToList();
            //添加连接到的构件
            var linkFitting = mepCurve.Document.GetElement(linkConList.FirstOrDefault().Owner.Id) as FamilyInstance;
            //拿到管件连接的所有管线
            List<MEPCurve> linkMC = GetLinkMepCurveList(linkFitting, mepCurve.Id, out fi, out endConnMCID);
            mepCurveList.AddRange(linkMC);
            return mepCurveList;
        }
        /// <summary>
        /// 计算单条机电线管设备的完整路径
        /// </summary>
        /// <param name="fitting"></param>
        /// <param name="linkId"></param>
        /// <param name="nodeFI"></param>
        /// <param name="endConnMCID"></param>
        /// <returns></returns>
        public List<MEPCurve> GetLinkMepCurveList(FamilyInstance fitting, ElementId linkId, out FamilyInstance nodeFI, out ElementId endConnMCID)
        {
            List<MEPCurve> mepCurveList = new List<MEPCurve>();
            nodeFI = null;
            endConnMCID = null;
            //拿到所有构件的连接件
            var fittingLinkConList = fitting.MEPModel.ConnectorManager.Connectors.Cast<Connector>().Where(x => x.IsConnected && x.AllRefs.Cast<Connector>().FirstOrDefault(m => m.Owner.Id == linkId) == null);
            //如果遇到有分支的，直接返回
            if (fittingLinkConList.Count() >= 2 || fittingLinkConList.Count() == 0)
            {
                nodeFI = fitting;
                endConnMCID = linkId;
                return mepCurveList;
            }
            foreach (var con in fittingLinkConList)
            {
                //找到对应连接的连接件
                List<Connector> linkConList = con.AllRefs.Cast<Connector>().Where(x => x.Owner.Id != con.Owner.Id).ToList();
                //添加连接到的构件
                var linkElement = fitting.Document.GetElement(linkConList.FirstOrDefault().Owner.Id);
                if (linkElement is FamilyInstance)
                {
                    mepCurveList.AddRange(GetLinkMepCurveList(linkElement as FamilyInstance, fitting.Id, out nodeFI, out endConnMCID));
                }
                else
                {
                    mepCurveList.AddRange(GetLinkMepCurveList(linkElement as MEPCurve, fitting.Id, out nodeFI, out endConnMCID));
                }
            }
            return mepCurveList;
        }
    }
    /// <summary>
    /// 结点类，三通或者四通为一个结点,选择的起点和终点也是一个结点
    /// </summary>
    public class NodeModel : IEquatable<NodeModel>, IEquatable<FamilyInstance>
    {
        /// <summary>
        /// 结点构件
        /// </summary>
        public FamilyInstance NodeFamilyInstance { get; set; }

        /// <summary>
        /// 未使用连接器集合
        /// </summary>
        public List<Connector> ConnectorList { get; set; } = new List<Connector>();


        /// <summary>
        /// 使用过的连接器和对应的连接条索引
        /// </summary>
        public Dictionary<Connector, int> UserConnectIndexDic { get; set; } = new Dictionary<Connector, int>();

        public NodeModel()
        {

        }
        public NodeModel(FamilyInstance fi)
        {
            NodeFamilyInstance = fi;
        }

        public bool Equals(NodeModel other)
        {
            try
            {
                if (other.NodeFamilyInstance == null || this.NodeFamilyInstance == null) return false;
                return other.NodeFamilyInstance.Id.IntegerValue == this.NodeFamilyInstance.Id.IntegerValue;
            }
            catch (Exception)
            {
                return false;
            }

        }

        public bool Equals(FamilyInstance other)
        {
            try
            {
                if (other == null || this.NodeFamilyInstance == null) return false;
                return other.Id.IntegerValue == this.NodeFamilyInstance.Id.IntegerValue;
            }
            catch (Exception)
            {
                return false;
            }
        }
    }
    /// <summary>
    /// 两个结点直接相连的类
    /// </summary>
    public class NodeLink
    {
        /// <summary>
        /// 第一个结点
        /// </summary>
        public NodeModel OneModel { get; set; }

        /// <summary>
        /// 第二个结点
        /// </summary>
        public NodeModel TwoModel { get; set; }

        /// <summary>
        /// 两个结点之间的线集合
        /// </summary>
        public List<MEPCurve> LinkMEPCurveList { get; set; } = new List<MEPCurve>();

        /// <summary>
        /// 连接的长度
        /// </summary>
        public double LinkLenght { get; set; } = 0;

        /// <summary>
        /// 是否标记
        /// </summary>
        public bool IsTag { get; set; } = false;

    }
}

步骤讲解

1.构建节点

节点：实体构件、三通、四通
节点筛选的原则：如果一个实体构件的连接器除前连接前管道外，还有两个以上（包含两个）的连接器时，判断为节点，结束一条线的循环。
节点属性（NodeModel）

属性备注
NodeFamilyInstance节点构件
ConnectorList未使用的连接器集合
UserConnectIndexDic字典类型，用来记录对应的连接器和索引

思路：
a.以起点为开始构建循环，然后返回一个FamilyInstance，通过查找总的节点判断是否存在当前FamilyInstance的节点，如果没有需要新建加入到总的节点集合中。
b.循环的结束点在所有的节点的连接器全部都用完时，就跳出。
在这里插入图片描述
c.因此可以得到9个节点，和对应的连接长度NodelLink实例

2. Dijkstra算法

具体思路可以参考以下的博客：
最短路径算法
下面是我简单的理解和总结
a.先简化上面的图形
在这里插入图片描述

b.根据节点和起点来构建一个NodeLink实例，用来记录具体的起点到达每个节点的距离。然后找到和起点相连的节点，选择距离最短的点为下一个起点，并且把旧起点标记为已经使用过。然后每次的循环都是找所有节点中没有标记使用过的节点，并且是距离最短的为下一个节点。这里可能有点绕，通过图片来讲解

找到最近点B，然后A标记为使用过.在这里插入图片描述
以B为起点，去修改与B相连的点的数值。数值替换的原则是，起点到改点的距离小于记录的距离时，附上新值
在这里插入图片描述

把B标记为已经使用，找下一个距离最近未使用过的点C，以C为新起点去更新距离数值
在这里插入图片描述
通过不断循环，到最后连接终点的点都被标记过的时候，就是整个循环路径寻找结束的时候，这样子就可以找出最短的路径了
在这里插入图片描述

写在最后

用来测试的样例较为简单，没有经过大量的项目推敲，可以交给大家去测试和修改，主要是提供一个解题的思路，希望可以帮到你~~

baobao熊
关注
  • 4
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
二次开发之最短路径分析源码
01-05
实现了最短路径分析的功能
求空间中点到线的最短距离（Revit二次开发）
weixin_46433786的博客
09-15 1089
在项目中，我们一般是用使用点先投影到线上面，然后再用这个点去和端点去算距离。 但是如果那个点不能投影到线上面时，就会出现一些计算不准确的问题。 也让我们尽量的避开RevitAPI中的一些坑。而且基本适用于所有点求点到直线距离的情况。 这次教给大家一个用几何的方法计算点A到线BC的距离。代码如下： public double GetPointToLineDistance(XYZ aPoint, Line l) { //先分别得到点的坐标 XYZ
ArcGIS二次开发基础教程(11)：网络分析之最短路径分析
H48662654的博客
11-10 4112
ArcGIS二次开发基础教程(11)：网络分析之最短路径分析 最短路径分析 这里直接调用了在mdb中建立好的网络数据集 //全局变量 private INetworkDataset my_networkDataset;//网络数据集 private INAContext my_NAContexts;//网络分析上下文 private IFeatureClass my_InputFeatureCla...
Revit二次开发的资源调用路径
硬核小青年的博客
08-24 1017
Revit 二次开发过程中，经常需要调用一些外部资源，例如图片、视频、文本文件等等，从而实现定制化的功能。对于界面图标或图片资源的使用，相对而言比较简单，具体见：Revit二次开发使用相对路径显示图片，而要在后台代码中顺利地拿到生成操作为Content的资源并不容易。可谓前有狼后有虎。 情况1：获取到的是Revit.exe的路径，而非dll路径 System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase Application...
Dynamo For Revit: Path of Travel 行进路径
极客BIM工作室
02-23 1132
前言 使用路线分析来计算从模型中的一个点行进到另一个点的距离和时间。 这是 Revit 在 2020 版本提供的新功能，这种带有半智能的功能也是 Revit 的一个特色。同时，Dynamo 也迅速提供了相应的节点，这确实可以方便实际中的应用，比如防火相关的计算。 路线分析 官方文档 使用行进路径图元，可以分析模型中两个选定点之间的行进距离和时间。 在平面视图中，通过选择起点和终点来建立行进路径。...
Revit二次开发之获取本机已安装的Revit版本与路径
biyusr的专栏
01-04 356
在revit安装目录下找到。
Revit二次开发 防止弹窗
12-31
使用Revit二次开发，commandData.Application.OpenAndActivateDocument打开文件时，revit可能会弹出找不到参照等提示框，此资源可避免提示框的弹出
Revit二次开发，创建任意视角的3d视图
09-23
文章对应地址：https://blog.csdn.net/mazhiyuan1981/article/details/108745615
Autodesk Revit二次开发基础教程 pdf
09-20
本書內容是Revit二次開發基礎類教程，共有15章，主要從如下幾個方面來構建：功能（事件、界面、宏），類層次（應用類、文檔類、元素、族等），不同專業（建築、結構、MEP各專業相關的API）。 本書適用於想要使用...
Revit二次开发示例
02-20
Revit二次开发示例
Revit二开根据导入CAD管道图生产管道（弯头、三通、四通）
10-24
revite 二次开发。用于导入的CAD图纸的管道翻模，生成包括弯头、三通、四通的管道
Revit二次开发源码大全之二
04-11
全部源码分为两部分上传。更多资源请关注Revit二次开发论坛http://revit.5d6d.com
Revit二次开发TestBIM工具集源代码
08-14
涵盖了Revit建筑中部分功能的二次开发源码，包括Ribbon菜单，模态/非模态对话框，实体创建，轴线编辑，实体编辑，实体标注等主要功能。功能目录如下： "绘制坐标轴" "查看Ribbon菜单信息" "调用Revit命令" "显示族样式信息" "添加轴线" "删除轴线" "轴线改名" "主辅轴标注转换" "重排轴线" "添加柱" "墙柱对齐" "添加墙" "添加梁" "墙搜楼板" "创建房间" "创建房间面积" "创建楼层面积" "标注墙长及洞口信息" "标注墙厚" "编辑墙长" "打断墙" "3DView局部显示" "3DView中实体选择显示" "创建阳台" "创建台阶" "创建坡道"
义博！Autodesk Revit二次开发基础教程.pdf
07-25
义博！Autodesk revit二次开发基础教程，强烈推荐，强烈推荐，强烈推荐，强烈推荐 !
Revit二次开发小技巧（十一）计算点投影到一个平面上的点
包包熊的博客
07-12 1306
在项目中遇到的一个问题，想把管道中的中心点投影到一个剖切视图上面，然后研究了一番，写了一个通用的方法，现在来记录一下。先上代码，后讲解~~~ 1、点投影到平面的方法（如下） /// <summary> /// 点投影到一个平面 /// </summary> /// <param name=""></param> /// <param name="xyz"></param&gt
Revit二次开发小火车工具集的复现
yingdajun的博客
11-03 966
这是复现了腿腿教学网麻蛋讲师所做的小火车工具集插件的代码。下面是Github的链接有需要可以下载。 https://github.com/yingdajun/BabyTrainCopyDemo
感谢帮我的人们（Revit二次开发）
weixin_46433786的博客
09-23 468
今天在某网站看到蛋总的免费资源被某些人拿来抄袭后改头换面，并以高价出售，感觉特别来气；作为蛋总免费分享资源的受益者，突然感慨万千，以这篇文章来表达一些自己的看法，希望作为Revit二次开发的爱好者在学习免费资源的同时能够有所自省，请拥有最起码的职业道德。 1、从来没有公开对蛋总说过感谢的话，感觉亏欠良久，在这里首先感谢蛋总（DikyEggs）的《小火车Revit二次开发教程 》，感谢蛋总；同时感谢BIMCC云课堂网站。作为Revit二次开发的引路人，从中我从一个零基础的建模员成功入门Revit二次开发，并自
Revit二次开发 管道生成三通——两管生成和三管生成
qq_31121227的博客
08-24 2219
本文主要参考以下博客 “revit二次开发 关于管道弯头、三通、四通的生成” using Autodesk.Revit.DB; using Autodesk.Revit.UI; using Autodesk.Revit.UI.Selection; using Autodesk.Revit.Attributes; using System.Linq; using System.Collections.Generic; using Autodesk.Revit.DB.Mechanical; using S
Revit二开 批量链接模型
weixin_46563153的博客
12-25 1290
往往有时候提交项目需要整合各专业的模型，需要链接模型，模型太多不想一个个点，可以批量插入链接模型或重新载入模型，下面直接上代码: MagicTools批量链接功能： 载入模型用到 OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.DefaultExt = "*.rvt"; var sts = openFileDialog.FileNames.ToList();//获取选择文件名 foreach
revit二次开发2018 revit二次开发 Viewport类
最新发布
12-14
Viewport类是Revit API中的一个类，用于创建和操作视口元素。下面是一个使用Viewport类创建视口的示例代码： ```python # 导入Revit API中的Viewport类 from Autodesk.Revit.DB import Viewport # 获取当前文档 doc = __revit__.ActiveUIDocument.Document # 获取要放置视图的图纸元素ID和视图元素ID viewSheetId = ElementId(1234) viewId = ElementId(5678) # 创建一个视口元素并将其添加到文档中 viewport = Viewport.Create(doc, viewSheetId, viewId, XYZ(0, 0, 0)) ``` 在上面的代码中，我们首先导入了Viewport类，然后获取了当前文档。接着，我们获取了要放置视图的图纸元素ID和视图元素ID，并使用Viewport类的Create方法创建了一个视口元素，并将其添加到文档中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

baobao熊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值