Shrlalgo.RvKits/ShrlAlgoToolkit.RevitCore/Extensions/ConnectorExtensions.cs

using System.Diagnostics;
using Autodesk.Revit.DB;
using Autodesk.Revit.DB.Electrical;

namespace ShrlAlgoToolkit.RevitCore.Extensions;

public static class ConnectorExtensions
{
    /// <summary>
    /// 连接件管件连接,同管径，都为管线创建活接头
    /// </summary>
    /// <param name="first"></param>
    /// <param name="second"></param>
    /// <returns>连接的管件</returns>
    public static FamilyInstance ConnectByFitting(this Connector first, Connector second)
    {
        if (first == null || second == null)
        {
            return null;
        }
        var document = first.Owner.Document;
        var isSameSize = false; //相同规格、尺寸
        if (first.Domain != second.Domain)
        {
            throw new ArgumentException("无法连接不同类型的管线");
        }

        switch (first.Domain)
        {
            case Domain.DomainHvac:
                {
                    if (first.Shape == second.Shape)
                    {
                        var shape = first.Shape;
                        //判断管径是否一致
                        isSameSize = shape is ConnectorProfileType.Oval or ConnectorProfileType.Rectangular
                            ? Math.Abs(first.Width - second.Width) < 0.0001 && Math.Abs(first.Height - second.Height) < 0.0001
                            : Math.Abs(first.Radius - second.Radius) < 0.0001;
                    }
                    break;
                }
            case Domain.DomainPiping:
                isSameSize = Math.Abs(first.Radius - second.Radius) < 0.0001;
                break;
            case Domain.DomainCableTrayConduit:
                {
                    if (first.Owner.GetType() == second.Owner.GetType())
                    {
                        if (second.Owner is Conduit)
                        {
                            isSameSize = Math.Abs(first.Radius - second.Radius) < 0.0001;
                        }
                        if (second.Owner is CableTray)
                        {
                            isSameSize = Math.Abs(first.Width - second.Width) < 0.0001 && Math.Abs(first.Height - second.Height) < 0.0001;
                        }
                    }
                    break;
                }
        }
        try
        {
            //平行时，创建过渡件和活接头
            if (first.CoordinateSystem.BasisZ.IsParallelTo(second.CoordinateSystem.BasisZ))
            {
                //管径一致时，根据情况创建活接头
                if (isSameSize)
                {
                    //有一个是族的时候，始终直接连接,不创建活接头
                    if (first.Owner is MEPCurve ^ second.Owner is MEPCurve)
                    {
                        if (!first.IsConnectedTo(second))
                        {
                            first.ConnectTo(second);
                        }
                    }
                    //都是管线
                    if (first.Owner is MEPCurve && second.Owner is MEPCurve)
                    {
                        return document.Create.NewUnionFitting(first, second);
                    }
                    //都是族的连接件
                    if (first.Owner is FamilyInstance && second.Owner is FamilyInstance)
                    {
                        first.ConnectTo(second);
                    }

                    return null;
                }
                else
                {
                    //管径不一致时，创建过渡件
                    if (first.Owner is MEPCurve)
                    {
                        return document.Create.NewTransitionFitting(first, second);
                    }
                    if (second.Owner is MEPCurve)
                    {
                        return document.Create.NewTransitionFitting(second, first);
                    }
                    //都是族的连接件
                    if (first.Owner is FamilyInstance && second.Owner is FamilyInstance)
                    {
                        first.ConnectTo(second);
                    }
                    return null;
                }
            }
            //不平行则创建弯头
            return document.Create.NewElbowFitting(first, second);
        }
        catch (Exception)
        {
            return null;
        }
    }
    
    /// <summary>
    /// 分支连接
    /// </summary>
    /// <param name="branch">支管连接件</param>
    /// <param name="connector"></param>
    /// <param name="connector1"></param>
    /// <returns></returns>
    public static FamilyInstance ConnectByTee(this Connector branch, Connector connector, Connector connector1)
    {
        var document = branch.Owner.Document;
        //获取垂直主管的向量
        var normal = connector.CoordinateSystem.BasisZ.CrossProduct(branch.CoordinateSystem.BasisZ);
        var vertical = connector.CoordinateSystem.BasisZ.CrossProduct(normal);

        var mainLine = Line.CreateUnbound(connector.Origin, connector.CoordinateSystem.BasisZ);
        var branchLine = Line.CreateUnbound(branch.Origin, branch.CoordinateSystem.BasisZ);
        //分支和主管的角度
        var cos = branch.CoordinateSystem.BasisZ.DotProduct(connector.CoordinateSystem.BasisZ);
        var angle = Math.Acos(cos);
        //主管和分支管的交点
        var intersect = mainLine.IntersectionPoint(branchLine);
        //垂直主管的分支管，为了创建默认三通
        var verticalLine = Line.CreateBound(intersect, intersect + (3.0 * vertical));
        //延长管线到交点处
        branch.Owner.SetLocationCurve((branch.Owner.GetCurve() as Line).ExtendLine(intersect));
        connector.Owner.SetLocationCurve((connector.Owner.GetCurve() as Line).ExtendLine(intersect));
        connector1.Owner.SetLocationCurve((connector1.Owner.GetCurve() as Line).ExtendLine(intersect));
        //复制支管创建垂直主管的管线
        var verticalMEPCurveId = ElementTransformUtils.CopyElement(document, branch.Owner.Id, XYZ.Zero).FirstOrDefault();
        var verticalMEPCurve = document.GetElement(verticalMEPCurveId) as MEPCurve;
        verticalMEPCurve.SetLocationCurve(verticalLine);
        //获取垂直管的连接件
        var tempBranchConnector = verticalMEPCurve.GetConnectors().GetNearestConnector(intersect);
        //创建三通
        var tee = document.Create.NewTeeFitting(connector, connector1, tempBranchConnector);
        if (tempBranchConnector.GetConnectedConnector().Owner.Id != tee.Id)
        {
            document.Delete(tempBranchConnector.GetConnectedConnector().Owner.Id);
        }
        document.Delete(verticalMEPCurveId);
        //三通中未连接的连接件即分支连接件
        var teeBranchConn = tee.GetConnectors(true).OfType<Connector>().FirstOrDefault();
        try
        {
            //设置三通角度
            teeBranchConn!.Angle = Math.PI - angle;
        }
        catch (Autodesk.Revit.Exceptions.InvalidOperationException)
        {
            Debug.WriteLine("无法修改管线角度");
        }
        document.Regenerate();
        //Connector branchFarConn = branch.Owner.GetConnectors().GetFarthestConnector(intersect);
        //Line newBranch = Line.CreateBound(branchFarConn.Origin, teeBranchConn.Origin);
        var l = branch.Owner.GetCurve() as Line;
        var newBranchLine = l.ExtendLine(teeBranchConn!.Origin);
        branch.Owner.SetLocationCurve(newBranchLine);
        //Line line = branch.Owner.GetCurve() as Line;
        //if (newBranch.Direction.IsAlmostEqualTo(line.Direction))
        //{
        //    (branch.Owner.Location as LocationCurve).Curve = newBranch;
        //}
        //else if (newBranch.Direction.IsAlmostEqualTo(-line.Direction))
        //{
        //    (branch.Owner.Location as LocationCurve).Curve = newBranch.CreateReversed();
        //}
        var newBranchConn = GetNearestConnector(branch.Owner.GetConnectors(), intersect);
        newBranchConn.ConnectByFitting(teeBranchConn);
        return tee;
    }

    /// <summary>
    ///    获得所有连接的元素
    /// </summary>
    /// <param name="startConnector">起始连接件</param>
    /// <param name="elemIdsConnected">连接的所有元素ID</param>
    public static void GetAllRefElementIds(this Connector startConnector, ICollection<ElementId> elemIdsConnected)
    {
        if (!startConnector.IsConnected)
        {
            return;
        }
        if (!elemIdsConnected.Contains(startConnector.Owner.Id))
        {
            elemIdsConnected.Add(startConnector.Owner.Id);
        }
        //连接的元素
        //得到与当前连接件连接的连接件
        foreach (Connector currentConn in startConnector.AllRefs)
        {
            //连接的连接件
            if (currentConn.ConnectorType == ConnectorType.End && currentConn.Owner.Id != startConnector.Owner.Id)
            {
                if (elemIdsConnected.Contains(currentConn.Owner.Id))
                {
                    continue;
                }
                elemIdsConnected.Add(currentConn.Owner.Id);
                var allConnectors = currentConn.Owner.GetConnectors(); //找到连接的连接件

                foreach (Connector item in allConnectors)
                {
                    if (startConnector.Origin.IsAlmostEqualTo(item.Origin)) //沿着往下找
                    {
                        continue;
                    }
                    GetAllRefElementIds(item, elemIdsConnected);
                }
            }
        }
    }

    /// <summary>
    ///    获得所有连接的元素
    /// </summary>
    /// <param name="startConnector">起始连接件</param>
    /// <param name="elemsConnected">连接的元素</param>
    public static void GetAllRefsElements(this Connector startConnector, ICollection<Element> elemsConnected)
    {
        if (!startConnector.IsConnected)
        {
            return;
        }
        if (!elemsConnected.Contains(startConnector.Owner))
        {
            elemsConnected.Add(startConnector.Owner);
        }
        //连接的元素
        //得到与当前连接件连接的连接件
        foreach (Connector currentConn in startConnector.AllRefs)
        {
            //连接的连接件
            if (currentConn.ConnectorType == ConnectorType.End && currentConn.Owner.Id != startConnector.Owner.Id)
            {
                if (elemsConnected.Contains(currentConn.Owner))
                {
                    continue;
                }
                elemsConnected.Add(currentConn.Owner);
                var allConnectors = currentConn.Owner.GetConnectors(); //找到连接的元素的连接件

                foreach (Connector item in allConnectors)
                {
                    if (startConnector.Origin.IsAlmostEqualTo(item.Origin)) //沿着往下找
                    {
                        continue;
                    }
                    GetAllRefsElements(item, elemsConnected);
                }
            }
        }
    }

    /// <summary>
    /// 获取与当前连接件已连接的连接件
    /// </summary>
    /// <param name="connector">当前连接件</param>
    /// <returns></returns>
    public static Connector GetConnectedConnector(this Connector connector)
    {
        return connector.IsConnected
            ? connector.AllRefs.Cast<Connector>().FirstOrDefault(c => ConnectorType.End == c.ConnectorType && !c.Owner.Id.Equals(connector.Owner.Id))
            : null;
    }
    /// <summary>
    /// 得到元素所有连接件
    /// </summary>
    /// <param name="element"></param>
    /// <param name="isUnused">True,获取未使用的连接件;False,获取所有连接件</param>
    /// <returns></returns>
    public static ConnectorSet GetConnectors(this Element element, bool isUnused = false) => element switch
    {
        FamilyInstance familyInstance => isUnused
            ? familyInstance.MEPModel?.ConnectorManager.UnusedConnectors
            : familyInstance.MEPModel?.ConnectorManager.Connectors,
        MEPCurve mepCurve => isUnused
            ? mepCurve.ConnectorManager.UnusedConnectors
            : mepCurve.ConnectorManager.Connectors,
        FabricationPart fabricationPart => isUnused
            ? fabricationPart.ConnectorManager.UnusedConnectors
            : fabricationPart.ConnectorManager.Connectors,
        _ => null
    };

    /// <summary>
    ///     从连接件延伸长度
    /// </summary>
    /// <param name="connector"></param>
    /// <returns></returns>
    public static double GetExtensionLength(this Connector connector)
    {
        return connector.Domain switch
        {
            Domain.DomainHvac when connector.Shape == ConnectorProfileType.Rectangular => (connector.Width * 0.2) + (connector.Height * 0.2),
            Domain.DomainHvac when connector.Shape == ConnectorProfileType.Oval => (connector.Width * 0.2) + (connector.Height * 0.2),
            Domain.DomainHvac when connector.Shape == ConnectorProfileType.Round => connector.Radius * 0.5,
            Domain.DomainPiping => connector.Radius * 4,
            Domain.DomainCableTrayConduit => 1,
            _ => 0.5
        };
    }

    /// <summary>
    ///     距离所选点最远的连接件
    /// </summary>
    /// <param name="set"></param>
    /// <param name="startPoint">选择点</param>
    /// <returns></returns>
    public static Connector GetFarthestConnector(this ConnectorSet set, XYZ startPoint)
    {
        Connector result = null;
        var minValue = double.MinValue;
        foreach (Connector connector in set)
        {
            var d = connector.Origin.DistanceTo(startPoint);
            if (d > minValue)
            {
                minValue = d;
                result = connector;
            }
        }

        return result;
    }
    /// <summary>
    /// 获取两个元素最远的连接件
    /// </summary>
    /// <param name="first"></param>
    /// <param name="second"></param>
    /// <param name="isUnused">是否包含已经连接</param>
    /// <returns></returns>
    public static List<Connector> GetFarthestConnectors(this MEPCurve first, MEPCurve second, bool isUnused = true)
    {
        var list = new List<Connector>();
        Connector conn = null;
        Connector conn2 = null;
        var distance = double.MinValue;
        foreach (Connector connTemp in first.GetConnectors(isUnused))
        {
            foreach (Connector connTemp2 in second.GetConnectors(isUnused))
            {
                var tempDistance = connTemp.Origin.DistanceTo(connTemp2.Origin);
                if (distance < tempDistance)
                {
                    distance = tempDistance;
                    conn = connTemp;
                    conn2 = connTemp2;
                }
            }
        }

        if (conn != null)
        {
            list.Add(conn);
        }

        if (conn2 != null)
        {
            list.Add(conn2);
        }
        return list;
    }

    ///// <summary>
    /////     流向相反，类型相同的管线连接件
    ///// </summary>
    ///// <param name="cA1">查询的连接件集合</param>
    ///// <param name="c">默认连接件</param>
    ///// <returns></returns>
    //public static Connector GetNearestConnector(Connector c, ConnectorSet cA1)
    //{
    //    Connector result = null;
    //    double num = double.MaxValue;
    //    foreach (Connector current in cA1)
    //    {
    //        if (current.IsConnected)
    //        {
    //            continue;
    //        }

    //        if (current.Origin == c.Origin) continue;
    //        double num3 = current.Origin.DistanceTo(c.Origin);
    //        if (num3 < num && current.Domain == c.Domain &&
    //            c.CoordinateSystem.BasisZ.DotProduct(current.CoordinateSystem.BasisZ) < -0.9)
    //        {
    //            num = num3;
    //            result = current;
    //        }
    //    }

    //    return result;
    //}


    /// <summary>
    ///     获取集合中距离最近的连接件（含未连接和已连接）
    /// </summary>
    /// <param name="set"></param>
    /// <param name="startPoint"></param>
    /// <returns></returns>
    public static Connector GetNearestConnector(this ConnectorSet set, XYZ startPoint)
    {
        Connector result = null;
        var maxValue = double.MaxValue;
        foreach (Connector connector in set)
        {
            var value = connector.Origin.DistanceTo(startPoint);
            if (value < maxValue)
            {
                maxValue = value;
                result = connector;
            }
        }

        return result;
    }

    /// <summary>
    ///     最接近的两个连接件(排除重叠)
    /// </summary>
    /// <param name="set1">连接件合集</param>
    /// <param name="set2">连接件合集</param>
    /// <param name="domain">查找需要过滤管线的类型,undefined则查找全部类型</param>
    /// <param name="exclusionConnected">排除已连接的连接件</param>
    /// <returns></returns>
    public static Connector GetNearestConnectorByConnectSet(
        ConnectorSet set1,
        ConnectorSet set2,
        Domain domain = Domain.DomainUndefined,
        bool exclusionConnected = false
    )
    {
        Connector result = null;
        var tempMax = double.MaxValue;
        foreach (Connector connector1 in set1)
        {
            if (exclusionConnected && connector1.IsConnected)
            {
                continue;
            }

            foreach (Connector connector2 in set2)
            {
                if (exclusionConnected && connector2.IsConnected)
                {
                    continue;
                }

                if (connector2.Origin == connector1.Origin)
                {
                    continue;
                }

                var distanceTo = connector2.Origin.DistanceTo(connector1.Origin);
                if (distanceTo < tempMax && (domain == Domain.DomainUndefined || connector2.Domain == domain))
                {
                    tempMax = distanceTo;
                    result = connector2;
                }
            }
        }

        return result;
    }

    /// <summary>
    /// 获取最近的连接件
    /// </summary>
    /// <param name="element1">第一个元素</param>
    /// <param name="element2"></param>
    /// <param name="isUnused"></param>
    /// <remarks>集合中的连接件的顺序与方法参数一一对应</remarks>
    /// <returns>返回最近的连接件集合</returns>
    public static List<Connector> GetNearestConnectors(this Element element1, Element element2, bool isUnused = true)
    {
        List<Connector> list = [];
        Connector conn = null;
        Connector conn2 = null;
        var distance = double.MaxValue;
        foreach (Connector connTemp in element1.GetConnectors(isUnused))
        {
            foreach (Connector connTemp2 in element2.GetConnectors(isUnused))
            {
                var tempDistance = connTemp.Origin.DistanceTo(connTemp2.Origin);
                if (distance > tempDistance)
                {
                    distance = tempDistance;
                    conn = connTemp;
                    conn2 = connTemp2;
                }
            }
        }
        if (conn != null)
        {
            list.Add(conn);
        }
        if (conn2 != null)
        {
            list.Add(conn2);
        }
        return list;
    }

    /// <summary>
    /// 同领域的最近连接件
    /// </summary>
    /// <param name="element1"></param>
    /// <param name="element2"></param>
    /// <param name="isUnused"></param>
    /// <returns>同领域的最近连接件，若无，则返回空集合</returns>
    public static List<Connector> GetNearestDomainConnectors(this Element element1, Element element2, bool isUnused = true)
    {
        List<Connector> list = [];
        Connector conn = null;
        Connector conn2 = null;
        var distance = double.MaxValue;
        foreach (Connector connTemp in element1.GetConnectors(isUnused))
        {
            foreach (Connector connTemp2 in element2.GetConnectors(isUnused))
            {
                var tempDistance = connTemp.Origin.DistanceTo(connTemp2.Origin);
                if (connTemp.Domain == connTemp2.Domain && distance > tempDistance)
                {
                    distance = tempDistance;
                    conn = connTemp;
                    conn2 = connTemp2;
                }
            }
        }
        if (conn != null)
        {
            list.Add(conn);
        }
        if (conn2 != null)
        {
            list.Add(conn2);
        }
        return list;
    }
}