revit二次开发 创建管道三通，管道四通。两根管、三根管、四根管

创建单跟水管

   /// <summary>
        /// 创建水管Pipe
        /// </summary>
        /// <returns></returns>
        public Pipe CreatePipe()
        {
            FilteredElementCollector elements = new FilteredElementCollector(document);
            //得到管道系统
            List<PipingSystemType> pipingSystemTypes = elements.OfClass(typeof(PipingSystemType)).Cast<PipingSystemType>().ToList();
            PipingSystemType pipingSystemType = null;//管道类型
            foreach (PipingSystemType item in pipingSystemTypes)
            {
                if (item.Name.Equals("家用冷水"))
                {
                    pipingSystemType = item;
                    break;
                }
            }

            FilteredElementCollector elements2 = new FilteredElementCollector(document);
            //得到管道类型
            List<PipeType> pipeTypes = elements2.OfClass(typeof(PipeType)).Cast<PipeType>().ToList();
            PipeType pipeType = null;//管道类型
            foreach (PipeType item in pipeTypes)
            {
                if (item.Name.Equals("标准"))
                {
                    pipeType = item;
                    break;
                }
            }
            Level level = document.ActiveView.GenLevel;
            XYZ point1 = uIDocument.Selection.PickPoint();
            XYZ point2 = uIDocument.Selection.PickPoint();
            //创建管道
            Pipe pipe = Pipe.Create(document, pipingSystemType.Id, pipeType.Id, level.Id, point1, point2);
            //设置参数
            Parameter parameter = pipe.get_Parameter(BuiltInParameter.RBS_OFFSET_PARAM);
            parameter.Set(2750.0.Tofoot());
            Parameter parameter2 = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_DIAMETER_PARAM);
            parameter2.Set(150.0.Tofoot());

            PipingSystemType pipingSystemType1 = null;
            foreach (PipingSystemType item in pipingSystemTypes)
            {
                if (item.Name.Equals("家用热水"))
                {
                    pipingSystemType1 = item;
                    break;
                }
            }
            Parameter parameter3 = pipe.get_Parameter(BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
            parameter3.Set(pipingSystemType1.Id);
            return pipe;
        }

创建三通 三根管

  /// <summary>
        /// 创建三通 三根管
        /// </summary>
        /// <param name="mEPCurve1">管</param>
        /// <param name="mEPCurve2">管</param>
        /// <param name="mEPCurve3">管</param>
        public FamilyInstance CreateTee(MEPCurve mEPCurve1, MEPCurve mEPCurve2, MEPCurve mEPCurve3)
        {
            //找出平行的两根管和找出不平行的一根管
            Line line1 = (mEPCurve1.Location as LocationCurve).Curve as Line;
            Line line2 = (mEPCurve2.Location as LocationCurve).Curve as Line;
            Line line3 = (mEPCurve3.Location as LocationCurve).Curve as Line;

            line1.GetEndPoint(1).Subtract(line1.GetEndPoint(0)).Normalize();
            //横管1
            MEPCurve parallelMEP1 = null;
            //横管2
            MEPCurve parallelMEP2 = null;
            //竖管
            MEPCurve verticalMEP = null;
            if (line1.Direction.IsAlmostEqualTo(line2.Direction) || line1.Direction.IsAlmostEqualTo(line2.Direction.Negate()))
            {
                parallelMEP1 = mEPCurve1;
                parallelMEP2 = mEPCurve2;
                if (!line3.Direction.IsAlmostEqualTo(line1.Direction) && !line3.Direction.IsAlmostEqualTo(line1.Direction.Negate()))
                {
                    verticalMEP = mEPCurve3;
                }
            }
            else if (line1.Direction.IsAlmostEqualTo(line3.Direction) || line1.Direction.IsAlmostEqualTo(line3.Direction.Negate()))
            {
                parallelMEP1 = mEPCurve1;
                parallelMEP2 = mEPCurve3;
                if (!line2.Direction.IsAlmostEqualTo(line1.Direction) && !line2.Direction.IsAlmostEqualTo(line1.Direction.Negate()))
                {
                    verticalMEP = mEPCurve2;
                }
            }
            else
            {
                parallelMEP1 = mEPCurve2;
                parallelMEP2 = mEPCurve3;
                if (!line1.Direction.IsAlmostEqualTo(line2.Direction) && !line1.Direction.IsAlmostEqualTo(line2.Direction.Negate()))
                {
                    verticalMEP = mEPCurve1;
                }
            }

            if (parallelMEP1 != null && parallelMEP2 != null && verticalMEP != null)
            {
                double minVal = double.MaxValue;
                Connector parallelMEP1Con = null;
                Connector parallelMEP2Con = null;
                Connector parallelMEP3Con = null;
                foreach (Connector con1 in parallelMEP1.ConnectorManager.Connectors)
                {
                    foreach (Connector con2 in parallelMEP2.ConnectorManager.Connectors)
                    {
                        double distance = con1.Origin.DistanceTo(con2.Origin);
                        if (distance < minVal)
                        {
                            minVal = distance;
                            parallelMEP1Con = con1;
                            parallelMEP2Con = con2;
                        }
                    }
                }
                if (parallelMEP1Con != null && parallelMEP1Con != null)
                {
                    minVal = double.MaxValue;
                    foreach (Connector con in verticalMEP.ConnectorManager.Connectors)
                    {
                        //连接器的点之间的距离
                        double distance = con.Origin.DistanceTo(parallelMEP1Con.Origin);
                        if (distance < minVal)
                        {
                            minVal = distance;
                            parallelMEP3Con = con;
                        }
                    }
                    if (parallelMEP3Con != null)
                    {
                        //创建三通
                        return document.Create.NewTeeFitting(parallelMEP1Con, parallelMEP2Con, parallelMEP3Con);
                    }
                }
            }
            return null;
        }

创建三通 两根管

  /// <summary>
        /// 创建三通 两根管
        /// </summary>
        /// <param name="mEPCurve1">被垂直的管</param>
        /// <param name="mEPCurve2">垂直的管</param>
        /// <returns></returns>
        public FamilyInstance CreateTeeByToMEPCurve(MEPCurve mEPCurve1, MEPCurve mEPCurve2)
        {
            Line mEPCurve1Line = (mEPCurve1.Location as LocationCurve).Curve as Line;
            Line mEPCurve2Line = (mEPCurve2.Location as LocationCurve).Curve as Line;
            //线到点的距离
            double distance1 = mEPCurve1Line.Distance(mEPCurve2Line.GetEndPoint(0));
            double distance2 = mEPCurve1Line.Distance(mEPCurve2Line.GetEndPoint(1));
            XYZ point = mEPCurve2Line.GetEndPoint(0);
            if (distance1 > distance2)
                point = mEPCurve2Line.GetEndPoint(1);
            //在mEPCurve1Line线上映射point点
            XYZ projectPoint = mEPCurve1Line.Project(point).XYZPoint;
            MEPCurve mEPCurve3 = BreakMEPCurve(mEPCurve1, projectPoint);

            //创建三通
            return CreateTee(mEPCurve1, mEPCurve3, mEPCurve2);
        }

创建四通 四根管

  /// <summary>
        /// 创建四通 四根管
        /// </summary>
        /// <param name="mEPCurve1"></param>
        /// <param name="mEPCurve2"></param>
        /// <param name="mEPCurve3"></param>
        /// <param name="mEPCurve4"></param>
        /// <returns></returns>
        public FamilyInstance CreateCross(MEPCurve mEPCurve1, MEPCurve mEPCurve2, MEPCurve mEPCurve3, MEPCurve mEPCurve4)
        {
            List<MEPCurve> mEPCurves = new List<MEPCurve>() { mEPCurve1, mEPCurve2, mEPCurve3, mEPCurve4 };
            Dictionary<int, Connector> keyValuePairs = new Dictionary<int, Connector>();
            for (int i = 0; i < mEPCurves.Count - 1; i++)
            {
                //拿到两根管
                MEPCurve mEP1 = mEPCurves[i];
                MEPCurve mEP2 = mEPCurves[i + 1];
                //找两根管最近的连接器
                double minDistance = double.MaxValue;
                Connector connector1 = null;
                Connector connector2 = null;
                foreach (Connector con1 in mEP1.ConnectorManager.Connectors)
                {
                    foreach (Connector con2 in mEP2.ConnectorManager.Connectors)
                    {
                        double distance = con1.Origin.DistanceTo(con2.Origin);
                        if (distance < minDistance)
                        {
                            minDistance = distance;
                            connector1 = con1;
                            connector2 = con2;
                        }
                    }
                }
                if (!keyValuePairs.ContainsKey(i))
                {
                    keyValuePairs.Add(i, connector1);
                }
                if (!keyValuePairs.ContainsKey(i + 1))
                {
                    keyValuePairs.Add(i + 1, connector2);
                }

            }
            List<Connector> connectors = new List<Connector>();
            for (int i = 0; i < keyValuePairs.Count; i++)
            {
                Connector con1 = keyValuePairs[i];
                if (connectors.Contains(con1))
                    continue;
                //con1的方向
                XYZ con1FX = con1.CoordinateSystem.BasisZ;
                for (int ai = i + 1; ai < keyValuePairs.Count; ai++)
                {
                    Connector con2 = keyValuePairs[ai];
                    //con2的方向
                    XYZ con2FX = con2.CoordinateSystem.BasisZ;
                    if (con1FX.IsAlmostEqualTo(con2FX) || con1FX.IsAlmostEqualTo(con2FX.Negate()))
                    {
                        connectors.Add(con1);
                        connectors.Add(con2);
                    }
                }
            }
            //创建四通
            FamilyInstance familyInstance = document.Create.NewCrossFitting(connectors[0], connectors[1], connectors[2], connectors[3]);//0与1平行 2与3平行
            return familyInstance;
        }