562 lines
33 KiB
C#
562 lines
33 KiB
C#
using System.Collections;
|
|
using System.Diagnostics;
|
|
|
|
using Autodesk.Revit.DB;
|
|
using Autodesk.Revit.DB.Electrical;
|
|
using Autodesk.Revit.DB.Mechanical;
|
|
using Autodesk.Revit.DB.Plumbing;
|
|
using Autodesk.Revit.UI;
|
|
using Autodesk.Revit.UI.Selection;
|
|
|
|
using Nice3point.Revit.Toolkit.External;
|
|
|
|
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
|
|
|
|
using Sai.Toolkit.Revit.Helpers;
|
|
|
|
namespace Sai.RvKits.RvMEP;
|
|
|
|
[Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
|
|
[Autodesk.Revit.Attributes.Regeneration(Autodesk.Revit.Attributes.RegenerationOption.Manual)]
|
|
internal class BloomConnectorCmd : ExternalCommand //根据连接件创建一根短管
|
|
{
|
|
public override void Execute()
|
|
{
|
|
try
|
|
{
|
|
var elemIds = UiDocument.Selection.GetElementIds();
|
|
if (elemIds.Count == 0)
|
|
{
|
|
var reference = UiDocument.Selection
|
|
.PickObject(
|
|
ObjectType.Element,
|
|
new FuncFilter(e => e is FamilyInstance ins && ins.GetConnectors(true).Size > 0),
|
|
"请选择族实例");
|
|
elemIds.Add(Document.GetElement(reference).Id);
|
|
}
|
|
|
|
foreach (var elemId in elemIds)
|
|
{
|
|
var pipeTypeId = Document.OfClass<PipeType>().FirstElementId();
|
|
var cableTrayTypeId = Document.OfClass<CableTrayType>().FirstElementId();
|
|
var conduitTypeId = Document.OfClass<ConduitType>().FirstElementId();
|
|
|
|
var ductTypeCollector = Document.OfClass<DuctType>().Cast<DuctType>();
|
|
var roundDuctTypeId = ElementId.InvalidElementId;
|
|
var rectangleDuctTypeId = ElementId.InvalidElementId;
|
|
var ovalDuctTypeId = ElementId.InvalidElementId;
|
|
//设置默认的风管类型
|
|
foreach (var ductType in ductTypeCollector)
|
|
{
|
|
if (ductType.FamilyName == "圆形风管" || ductType.FamilyName.Contains("Round Duct"))
|
|
{
|
|
roundDuctTypeId = ductType.Id;
|
|
}
|
|
else if (ductType.FamilyName == "矩形风管" || ductType.FamilyName.Contains("Rectangular Duct"))
|
|
{
|
|
rectangleDuctTypeId = ductType.Id;
|
|
}
|
|
else if (ductType.FamilyName == "椭圆形风管" || ductType.FamilyName.Contains("Oval Duct"))
|
|
{
|
|
ovalDuctTypeId = ductType.Id;
|
|
}
|
|
}
|
|
var fabricationConfiguration = FabricationConfiguration.GetFabricationConfiguration(Document);
|
|
|
|
var elem = Document.GetElement(elemId);
|
|
if (elem.GetConnectors(true).IsEmpty && elem is not FamilyInstance)
|
|
{
|
|
continue;
|
|
}
|
|
CableTray referCabTray = null;
|
|
Conduit referConduit = null;
|
|
//根据连接件拿到连接的管线的类型
|
|
foreach (Connector conn in elem.GetConnectors())
|
|
{
|
|
if (conn.IsConnected)
|
|
{
|
|
var connector = conn.GetConnectedConnector();
|
|
if (connector == null)
|
|
{
|
|
continue;
|
|
}
|
|
if (conn.Domain == Domain.DomainPiping && connector.Owner is Pipe)
|
|
{
|
|
pipeTypeId = connector.Owner.GetTypeId();
|
|
}
|
|
else if (conn.Domain == Domain.DomainHvac)
|
|
{
|
|
switch (connector.Shape)
|
|
{
|
|
case ConnectorProfileType.Invalid:
|
|
break;
|
|
case ConnectorProfileType.Round:
|
|
roundDuctTypeId = connector.Owner.GetTypeId();
|
|
break;
|
|
case ConnectorProfileType.Rectangular:
|
|
rectangleDuctTypeId = connector.Owner.GetTypeId();
|
|
break;
|
|
case ConnectorProfileType.Oval:
|
|
ovalDuctTypeId = connector.Owner.GetTypeId();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else if (conn.Domain == Domain.DomainCableTrayConduit)
|
|
{
|
|
if (connector.Owner is CableTray cableTray)
|
|
{
|
|
referCabTray = cableTray;
|
|
cableTrayTypeId = cableTray.GetTypeId();
|
|
}
|
|
else if (connector.Owner is Conduit conduit)
|
|
{
|
|
referConduit = conduit;
|
|
conduitTypeId = conduit.GetTypeId();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
Document.Invoke(
|
|
_ =>
|
|
{
|
|
var connectors = elem.GetConnectors(true);
|
|
foreach (Connector connector in connectors)
|
|
{
|
|
Element element = null;
|
|
if (elem.Category.Id.IntegerValue == (int)BuiltInCategory.OST_FabricationPipework)
|
|
{
|
|
var serviceId = (elem as FabricationPart).ServiceId;
|
|
var button = fabricationConfiguration.GetService(serviceId).GetButton(0, 0);
|
|
var fabricationPart = FabricationPart.Create(Document, button, 0, elem.LevelId);
|
|
var enumerator2 = fabricationPart.ConnectorManager.Connectors.GetEnumerator();
|
|
if (enumerator2.MoveNext())
|
|
{
|
|
var connector2 = (Connector)enumerator2.Current;
|
|
ElementTransformUtils.MoveElement(
|
|
Document,
|
|
fabricationPart.Id,
|
|
connector.Origin - connector2.Origin
|
|
);
|
|
var basisZ = connector.CoordinateSystem.BasisZ;
|
|
var basisZ2 = connector2.CoordinateSystem.BasisZ;
|
|
var num = basisZ.DotProduct(basisZ2);
|
|
if (Math.Abs(num - -1.0) < 0.0001)
|
|
{
|
|
connector2.ConnectTo(connector);
|
|
|
|
continue;
|
|
}
|
|
|
|
var xyz = basisZ.CrossProduct(basisZ2);
|
|
|
|
var line = Line.CreateBound(connector.Origin, connector.Origin + (10000000000000000.0 * xyz));
|
|
var angleTo = basisZ.AngleTo(basisZ2);
|
|
var angle = Math.PI - angleTo;
|
|
ElementTransformUtils.RotateElement(Document, fabricationPart.Id, line, angle);
|
|
if (connector2.Shape == ConnectorProfileType.Invalid)
|
|
{
|
|
connector2.Radius = connector.Radius;
|
|
}
|
|
else
|
|
{
|
|
connector2.Width = connector.Width;
|
|
connector2.Height = connector.Height;
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
var extensionLength = connector.GetExtensionLength();
|
|
var origin = connector.Origin;
|
|
//延伸后的点
|
|
var xyz2 = origin + (extensionLength * connector.CoordinateSystem.BasisZ);
|
|
var levelId = elem.LevelId;
|
|
if (levelId == ElementId.InvalidElementId)
|
|
{
|
|
var pa = elem.get_Parameter(BuiltInParameter.RBS_START_LEVEL_PARAM);
|
|
if (pa != null)
|
|
{
|
|
levelId = pa.AsElementId();
|
|
}
|
|
|
|
}
|
|
|
|
if (levelId == ElementId.InvalidElementId)
|
|
{
|
|
if (elem is FamilyInstance { Host: Level } instance)
|
|
{
|
|
levelId = instance.Host.Id;
|
|
}
|
|
}
|
|
|
|
switch (connector.Domain)
|
|
{
|
|
//未定义
|
|
case Domain.DomainUndefined:
|
|
break;
|
|
//风管
|
|
case Domain.DomainHvac:
|
|
//var mechanicalSystemTypes = new FilteredElementCollector(Document)
|
|
// .OfClass(typeof(MechanicalSystemType))
|
|
// .Cast<MechanicalSystemType>();
|
|
////风管系统类型
|
|
//var mechanicalSystem =
|
|
// connector.MEPSystem == null
|
|
// ? connector.DuctSystemType switch
|
|
// {
|
|
// //送风
|
|
// DuctSystemType.SupplyAir
|
|
// => mechanicalSystemTypes.FirstOrDefault(
|
|
// pst =>
|
|
// pst.SystemClassification
|
|
// == Autodesk.Revit.DB.MEPSystemClassification.SupplyAir
|
|
// ),
|
|
// //回风
|
|
// DuctSystemType.ReturnAir
|
|
// => mechanicalSystemTypes.FirstOrDefault(
|
|
// pst =>
|
|
// pst.SystemClassification
|
|
// == Autodesk.Revit.DB.MEPSystemClassification.ReturnAir
|
|
// ),
|
|
// //排风
|
|
// DuctSystemType.ExhaustAir
|
|
// => mechanicalSystemTypes.FirstOrDefault(
|
|
// pst =>
|
|
// pst.SystemClassification
|
|
// == Autodesk.Revit.DB.MEPSystemClassification.ExhaustAir
|
|
// ),
|
|
// _
|
|
// => mechanicalSystemTypes.FirstOrDefault(
|
|
// pst =>
|
|
// pst.SystemClassification
|
|
// == Autodesk.Revit.DB.MEPSystemClassification.OtherAir
|
|
// )
|
|
// }
|
|
// : Document.GetElement(connector.MEPSystem.GetTypeId()) as MechanicalSystemType;
|
|
|
|
//if (new FilteredElementCollector(Document).OfClass(typeof(DuctType)).FirstElement() is not DuctType)
|
|
//{
|
|
// break;
|
|
//}
|
|
|
|
//风管形状
|
|
switch (connector.Shape)
|
|
{
|
|
case ConnectorProfileType.Round:
|
|
element = Duct.Create(
|
|
Document,
|
|
roundDuctTypeId,
|
|
levelId,
|
|
connector,
|
|
xyz2
|
|
);
|
|
|
|
Document.Regenerate();
|
|
element.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM).Set(connector.Radius * 2);
|
|
break;
|
|
|
|
case ConnectorProfileType.Rectangular:
|
|
element = Duct.Create(
|
|
Document,
|
|
rectangleDuctTypeId,
|
|
levelId,
|
|
connector,
|
|
xyz2
|
|
);
|
|
Document.Regenerate();
|
|
var width = Math.Max(connector.Width, connector.Height);
|
|
var height = Math.Min(connector.Width, connector.Height);
|
|
element.get_Parameter(BuiltInParameter.RBS_CURVE_WIDTH_PARAM).Set(width);
|
|
element.get_Parameter(BuiltInParameter.RBS_CURVE_HEIGHT_PARAM).Set(height);
|
|
break;
|
|
|
|
case ConnectorProfileType.Oval:
|
|
element = Duct.Create(Document, ovalDuctTypeId, levelId, connector, xyz2);
|
|
Document.Regenerate();
|
|
var w = Math.Max(connector.Width, connector.Height);
|
|
var h = Math.Min(connector.Width, connector.Height);
|
|
element.get_Parameter(BuiltInParameter.RBS_CURVE_WIDTH_PARAM).Set(w);
|
|
element.get_Parameter(BuiltInParameter.RBS_CURVE_HEIGHT_PARAM).Set(h);
|
|
break;
|
|
|
|
default:
|
|
element = Duct.Create(
|
|
Document,
|
|
roundDuctTypeId,
|
|
levelId,
|
|
connector,
|
|
xyz2
|
|
);
|
|
break;
|
|
}
|
|
|
|
break;
|
|
//电气
|
|
case Domain.DomainElectrical:
|
|
break;
|
|
//水管
|
|
case Domain.DomainPiping:
|
|
var pipingSystemTypes = new FilteredElementCollector(Document)
|
|
.OfClass(typeof(PipingSystemType))
|
|
.Cast<PipingSystemType>();
|
|
if (pipeTypeId == ElementId.InvalidElementId)
|
|
{
|
|
pipeTypeId = Document.OfClass<PipeType>().FirstElementId();
|
|
}
|
|
var system = connector.MEPSystem;
|
|
var pipingSystemType =
|
|
system != null
|
|
? Document.GetElement(system.GetTypeId()) as PipingSystemType
|
|
: connector.PipeSystemType switch
|
|
{
|
|
//循环供水
|
|
PipeSystemType.SupplyHydronic
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.SupplyHydronic
|
|
),
|
|
//循环回水
|
|
PipeSystemType.ReturnHydronic
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.ReturnHydronic
|
|
),
|
|
//卫生设备
|
|
PipeSystemType.Sanitary
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.Sanitary
|
|
),
|
|
//家用热水
|
|
PipeSystemType.DomesticHotWater
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.DomesticHotWater
|
|
),
|
|
//家用冷水
|
|
PipeSystemType.DomesticColdWater
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.DomesticColdWater
|
|
),
|
|
//其他
|
|
PipeSystemType.OtherPipe
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.OtherPipe
|
|
),
|
|
//湿式消防系统
|
|
PipeSystemType.FireProtectWet
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.FireProtectWet
|
|
),
|
|
//干式消防系统
|
|
PipeSystemType.FireProtectDry
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.FireProtectDry
|
|
),
|
|
//预作用消防系统
|
|
PipeSystemType.FireProtectPreaction
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.FireProtectPreaction
|
|
),
|
|
//其他消防系统
|
|
PipeSystemType.FireProtectOther
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.FireProtectOther
|
|
),
|
|
//通风孔
|
|
PipeSystemType.Vent
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.Vent
|
|
),
|
|
_
|
|
=> pipingSystemTypes.FirstOrDefault(
|
|
pst =>
|
|
pst.SystemClassification
|
|
== Autodesk.Revit.DB.MEPSystemClassification.OtherPipe
|
|
)
|
|
};
|
|
|
|
element = Pipe.Create(Document, pipingSystemType.Id, pipeTypeId, levelId, origin, xyz2);
|
|
element.get_Parameter(BuiltInParameter.RBS_PIPE_DIAMETER_PARAM).Set(connector.Radius * 2);
|
|
break;
|
|
//电力
|
|
case Domain.DomainCableTrayConduit:
|
|
//if (cableTrayTypeId == ElementId.InvalidElementId)
|
|
//{
|
|
// cableTrayTypeId = new FilteredElementCollector(Document)
|
|
// .OfClass(typeof(CableTrayType))
|
|
// .FirstElementId();
|
|
//}
|
|
//if (conduitTypeId == ElementId.InvalidElementId)
|
|
//{
|
|
// conduitTypeId = new FilteredElementCollector(Document)
|
|
// .OfClass(typeof(ConduitType))
|
|
// .FirstElementId();
|
|
//}
|
|
|
|
|
|
//switch (connector.ElectricalSystemType)
|
|
//{
|
|
// //电力
|
|
// case ElectricalSystemType.PowerCircuit:
|
|
|
|
// break;
|
|
//}
|
|
|
|
switch (connector.Shape)
|
|
{
|
|
case ConnectorProfileType.Invalid:
|
|
break;
|
|
|
|
case ConnectorProfileType.Round:
|
|
element = Conduit.Create(Document, conduitTypeId, origin, xyz2, levelId);
|
|
element.get_Parameter(BuiltInParameter.RBS_CONDUIT_DIAMETER_PARAM).Set(connector.Radius * 2);
|
|
if (referConduit != null)
|
|
{
|
|
var value = referConduit.get_Parameter(
|
|
BuiltInParameter.RBS_CTC_SERVICE_TYPE)
|
|
.AsString();
|
|
element.get_Parameter(BuiltInParameter.RBS_CTC_SERVICE_TYPE).Set(value);
|
|
}
|
|
break;
|
|
|
|
case ConnectorProfileType.Rectangular:
|
|
var width = Math.Max(connector.Width, connector.Height);
|
|
var height = Math.Min(connector.Width, connector.Height);
|
|
element = CableTray.Create(Document, cableTrayTypeId, origin, xyz2, levelId);
|
|
element.get_Parameter(BuiltInParameter.RBS_CABLETRAY_WIDTH_PARAM).Set(width);
|
|
element.get_Parameter(BuiltInParameter.RBS_CABLETRAY_HEIGHT_PARAM).Set(height);
|
|
if (referCabTray != null)
|
|
{
|
|
var value = referCabTray.get_Parameter(
|
|
BuiltInParameter.RBS_CTC_SERVICE_TYPE)
|
|
.AsString();
|
|
element.get_Parameter(BuiltInParameter.RBS_CTC_SERVICE_TYPE).Set(value);
|
|
}
|
|
break;
|
|
|
|
case ConnectorProfileType.Oval:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
Document.Regenerate();
|
|
//新建管线连接
|
|
if (element == null)
|
|
{
|
|
continue;
|
|
}
|
|
var curve = element as MEPCurve;
|
|
var conns = curve.ConnectorManager.UnusedConnectors.Cast<Connector>();
|
|
foreach (var connect in conns)
|
|
{
|
|
if (connect.Origin.IsAlmostEqualTo(connector.Origin))
|
|
{
|
|
Debug.WriteLine("新建管线：");
|
|
Debug.WriteLine(connect.CoordinateSystem.BasisX);
|
|
Debug.WriteLine(connect.CoordinateSystem.BasisY);
|
|
Debug.WriteLine(connect.CoordinateSystem.BasisZ);
|
|
Debug.WriteLine("管件：");
|
|
Debug.WriteLine(connector.CoordinateSystem.BasisX);
|
|
Debug.WriteLine(connector.CoordinateSystem.BasisY);
|
|
Debug.WriteLine(connector.CoordinateSystem.BasisZ);
|
|
var isStandMEPCurve = connect.CoordinateSystem.BasisZ.CrossProduct(XYZ.BasisZ).IsAlmostEqualTo(XYZ.Zero);
|
|
|
|
if (isStandMEPCurve)
|
|
{
|
|
var angleX = Math.Acos(connect.CoordinateSystem.BasisX.DotProduct(connector.CoordinateSystem.BasisX));
|
|
Debug.WriteLine(angleX);
|
|
var crossProduct = connect.CoordinateSystem.BasisX
|
|
.CrossProduct(connector.CoordinateSystem.BasisX).Normalize();
|
|
var angle = Math.Acos(connect.CoordinateSystem.BasisX.DotProduct(connector.CoordinateSystem.BasisX));
|
|
if (crossProduct.IsAlmostEqualTo(XYZ.Zero))
|
|
{
|
|
if (connect.CoordinateSystem.BasisX
|
|
.IsAlmostEqualTo(connector.CoordinateSystem.BasisX))
|
|
{
|
|
ElementTransformUtils.RotateElement(
|
|
Document,
|
|
element.Id,
|
|
Line.CreateUnbound(origin, XYZ.BasisZ),
|
|
Math.PI / 2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (angleX > Math.PI / 2)
|
|
{
|
|
ElementTransformUtils.RotateElement(
|
|
Document,
|
|
element.Id,
|
|
Line.CreateUnbound(origin, XYZ.BasisZ),
|
|
angleX - Math.PI / 2);
|
|
}
|
|
else
|
|
{
|
|
ElementTransformUtils.RotateElement(
|
|
Document,
|
|
element.Id,
|
|
Line.CreateUnbound(origin, XYZ.BasisZ),
|
|
Math.PI / 2 - angleX);
|
|
}
|
|
}
|
|
//if (Math.Abs(angleX - Math.PI / 2) > 0.001)
|
|
//{
|
|
// ElementTransformUtils.RotateElement(
|
|
// Document,
|
|
// element.Id,
|
|
// Line.CreateUnbound(origin, crossProduct),
|
|
// angleX - Math.PI / 2
|
|
// );
|
|
// Debug.WriteLine("旋转后新建管线：");
|
|
// Debug.WriteLine(connect.CoordinateSystem.BasisX);
|
|
// Debug.WriteLine(connect.CoordinateSystem.BasisY);
|
|
// Debug.WriteLine(connect.CoordinateSystem.BasisZ);
|
|
// Document.Regenerate();
|
|
// angle = Math.Acos(connect.CoordinateSystem.BasisX.DotProduct(connector.CoordinateSystem.BasisX));
|
|
// Debug.WriteLine(nameof(angle) + angle);
|
|
//}
|
|
}
|
|
var conn = elem.GetConnectors(true).GetNearestConnector(connector.Origin);
|
|
if (!connect.IsConnectedTo(connector))
|
|
{
|
|
connect.ConnectTo(connector);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"引出短管"
|
|
);
|
|
}
|
|
}
|
|
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
|
|
{
|
|
Result = Result.Cancelled;
|
|
}
|
|
}
|
|
}
|