1052 lines
37 KiB
C#
1052 lines
37 KiB
C#
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
|
||
using Autodesk.Revit.DB;
|
||
using Autodesk.Revit.UI;
|
||
|
||
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
|
||
|
||
namespace Szmedi.Toolkit.RvExtensions;
|
||
|
||
public static class ElementExtensions
|
||
{
|
||
/// <summary>
|
||
/// 容差
|
||
/// </summary>
|
||
private const double Tolerance = 0.0001;
|
||
/// <summary>
|
||
/// 有类型定义的DirectShape
|
||
/// </summary>
|
||
/// <param name="doc"></param>
|
||
/// <param name="definitionId">定义名称，即是族名称、类型名称（强制一致），创建多个实例时，如果相同，则会合并在一个族中</param>
|
||
/// <param name="category">族类别</param>
|
||
/// <param name="geos">几何</param>
|
||
/// <returns></returns>
|
||
public static DirectShape CreateDirectShapeInstance(this Document doc, string definitionId, BuiltInCategory category, List<GeometryObject> geos)
|
||
{
|
||
DirectShapeLibrary directShapeLibrary = DirectShapeLibrary.GetDirectShapeLibrary(doc);
|
||
ElementId directShapeTypeId = directShapeLibrary.FindDefinitionType(definitionId);
|
||
if (doc.GetElement(directShapeTypeId) == null)
|
||
{
|
||
var directShapeType = DirectShapeType.Create(doc, definitionId, new ElementId(category));
|
||
directShapeTypeId = directShapeType.Id;
|
||
directShapeLibrary.AddDefinitionType(definitionId, directShapeTypeId);
|
||
}
|
||
//else
|
||
//{
|
||
// directShapeLibrary.AddDefinition(definitionId, geos);
|
||
//}
|
||
var shape = DirectShape.CreateElementInstance(doc, directShapeTypeId, new ElementId(category), definitionId, Transform.Identity);
|
||
//shape.SetTypeId(directShapeTypeId);
|
||
shape.SetName(definitionId);
|
||
shape.SetShape(geos);
|
||
return shape;
|
||
}
|
||
/// <summary>
|
||
/// 已经打开的视图中缩放视图，最大化图元
|
||
/// </summary>
|
||
/// <param name="view"></param>
|
||
/// <param name="uidoc"></param>
|
||
/// <param name="elementId"></param>
|
||
/// <param name="extend">扩宽范围</param>
|
||
public static void ZoomElement(this View view, UIDocument uidoc, ElementId elementId, int extend = 2)
|
||
{
|
||
var elem = uidoc.Document.GetElement(elementId);
|
||
|
||
if (!elem.IsValidObject || !elem.IsVisible(view)) return;
|
||
var box = elem.get_BoundingBox(view);
|
||
if (box == null) return;
|
||
box = box.Extend(extend);
|
||
var uiView = uidoc.GetOpenUIViews().FirstOrDefault(v => v.ViewId == uidoc.ActiveGraphicalView.Id);
|
||
uiView?.ZoomAndCenterRectangle(box.Min, box.Max);
|
||
}
|
||
public static bool IsVisible(this Element elem, View view) => FilteredElementCollector.IsViewValidForElementIteration(elem.Document, view.Id)
|
||
&& new FilteredElementCollector(elem.Document, view.Id).ToElementIds().Any(id => id == elem.Id);
|
||
/// <summary>
|
||
/// 无名称定义的DirectShape
|
||
/// </summary>
|
||
/// <param name="doc"></param>
|
||
/// <param name="geos"></param>
|
||
/// <param name="category"></param>
|
||
/// <returns></returns>
|
||
public static DirectShape CreateDirectShape(this Document doc, List<GeometryObject> geos, BuiltInCategory category)
|
||
{
|
||
var shape = DirectShape.CreateElement(doc, new ElementId(category));
|
||
shape.SetShape(geos);
|
||
return shape;
|
||
}
|
||
/// <summary>
|
||
/// 扩展包围盒的大小
|
||
/// </summary>
|
||
/// <param name="boundingBox"></param>
|
||
/// <param name="distance"></param>
|
||
/// <returns></returns>
|
||
public static BoundingBoxXYZ Extend(this BoundingBoxXYZ boundingBox, double distance = 2.0)
|
||
{
|
||
var transform = boundingBox.Transform;
|
||
var max = boundingBox.Max + distance * (transform.BasisX + transform.BasisY + transform.BasisZ);
|
||
var min = boundingBox.Min - distance * (transform.BasisX + transform.BasisY + transform.BasisZ);
|
||
return new BoundingBoxXYZ() { Max = max, Min = min, Transform = transform };
|
||
}
|
||
private static List<T> GetGeoObjects<T>(this GeometryObject geoObject)
|
||
where T : GeometryObject
|
||
{
|
||
List<T> geometryObjects = [];
|
||
|
||
if (geoObject is Solid instSolid)
|
||
{
|
||
if (typeof(T) == typeof(Solid))
|
||
{
|
||
geometryObjects.Add(instSolid as T);
|
||
}
|
||
if (typeof(T) == typeof(Face) && instSolid.Faces.Size > 0)
|
||
{
|
||
geometryObjects.AddRange(instSolid.Faces.Cast<T>());
|
||
}
|
||
else if (typeof(T) == typeof(Edge) && instSolid.Edges.Size > 0)
|
||
{
|
||
geometryObjects.AddRange(instSolid.Edges.Cast<T>());
|
||
}
|
||
}
|
||
|
||
return geometryObjects;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 主次分支连接
|
||
/// </summary>
|
||
/// <param name="mainMepCurve">主管</param>
|
||
/// <param name="branchMepCurve">分支</param>
|
||
public static void ConnectTo(this MEPCurve mainMepCurve, MEPCurve branchMepCurve)
|
||
{
|
||
var document = mainMepCurve.Document;
|
||
var unboundBranchCurve = branchMepCurve.GetLocCurve();
|
||
unboundBranchCurve.MakeUnbound();
|
||
var unboundMainCurve = mainMepCurve.GetLocCurve();
|
||
unboundMainCurve.MakeUnbound();
|
||
var intersection = unboundBranchCurve.IntersectionPoint(unboundMainCurve) ?? throw new InvalidOperationException("主次分支管线不存在交点");
|
||
var line = mainMepCurve.GetLocCurve() as Line;
|
||
//根据交点在管线内的位置，判断是形成弯头还是三通
|
||
if (line.IsInsideEx(intersection, 0.5)) //三通
|
||
{
|
||
var newMainMEPCurveId = mainMepCurve.BreakByPoint(intersection);
|
||
var newMainMEPCurve = document.GetElement(newMainMEPCurveId) as MEPCurve;
|
||
var mainConnectors = ConnectorExtensions.GetNearestConnectors(mainMepCurve, newMainMEPCurve);
|
||
var branchConnector = branchMepCurve.GetConnectors(true).GetNearestConnector(intersection);
|
||
|
||
/* 项目“Szmedi.Toolkit (net48)”的未合并的更改
|
||
在此之前:
|
||
branchConnector.ConnectByTee(mainConnectors[0], mainConnectors[1]);
|
||
在此之后:
|
||
branchConnector.ConnectByTee(mainConnectors[0], mainConnectors[1]);
|
||
*/
|
||
branchConnector.ConnectByTee(mainConnectors[0], mainConnectors[1]);
|
||
}
|
||
else //弯头
|
||
{
|
||
var conn = mainMepCurve.GetConnectors(true).GetNearestConnector(intersection);
|
||
var conn2 = branchMepCurve.GetConnectors(true).GetNearestConnector(intersection);
|
||
|
||
/* 项目“Szmedi.Toolkit (net48)”的未合并的更改
|
||
在此之前:
|
||
conn.ConnectByFitting(conn2);
|
||
在此之后:
|
||
conn.ConnectByFitting(conn2);
|
||
*/
|
||
conn.ConnectByFitting(conn2);
|
||
}
|
||
}
|
||
public static HermiteSpline ConverToHermiteSpline(this PolyLine polyLine)
|
||
{
|
||
var list = polyLine.GetCoordinates();
|
||
return HermiteSpline.Create(list, false);
|
||
}
|
||
|
||
/// <summary>
|
||
|
||
/* 项目“Szmedi.Toolkit (net48)”的未合并的更改
|
||
在此之前:
|
||
/// 分支连接
|
||
/// </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)
|
||
{
|
||
doc doc = branch.Owner.doc;
|
||
//获取垂直主管的向量
|
||
XYZ normal = connector.CoordinateSystem.BasisZ.CrossProduct(branch.CoordinateSystem.BasisZ);
|
||
XYZ vertical = connector.CoordinateSystem.BasisZ.CrossProduct(normal);
|
||
|
||
Line mainLine = Line.CreateUnbound(connector.Origin, connector.CoordinateSystem.BasisZ);
|
||
Line branchLine = Line.CreateUnbound(branch.Origin, branch.CoordinateSystem.BasisZ);
|
||
//分支和主管的角度
|
||
double cos = branch.CoordinateSystem.BasisZ.DotProduct(connector.CoordinateSystem.BasisZ);
|
||
double angle = Math.Acos(cos);
|
||
//主管和分支管的交点
|
||
XYZ intersect = mainLine.IntersectionPoint(branchLine);
|
||
//垂直主管的分支管，为了创建默认三通
|
||
Line verticalLine = Line.CreateBound(intersect, intersect + (3.0 * vertical));
|
||
//延长管线到交点处
|
||
branch.Owner.SetLocationCurve((branch.Owner.GetLocCurve() as Line).ExtendLine(intersect));
|
||
connector.Owner.SetLocationCurve((connector.Owner.GetLocCurve() as Line).ExtendLine(intersect));
|
||
connector1.Owner.SetLocationCurve((connector1.Owner.GetLocCurve() as Line).ExtendLine(intersect));
|
||
//复制支管创建垂直主管的管线
|
||
ElementId verticalMEPCurveId = ElementTransformUtils.CopyElement(doc, branch.Owner.Id, XYZ.Zero).FirstOrDefault();
|
||
MEPCurve verticalMEPCurve = doc.GetElement(verticalMEPCurveId) as MEPCurve;
|
||
verticalMEPCurve.SetLocationCurve(verticalLine);
|
||
//获取垂直管的连接件
|
||
Connector tempBranchConnector = verticalMEPCurve.GetConnectors().GetNearestConnector(intersect);
|
||
//创建三通
|
||
FamilyInstance tee = doc.Create.NewTeeFitting(connector, connector1, tempBranchConnector);
|
||
if (tempBranchConnector.GetConnectedConnector().Owner.Id != tee.Id)
|
||
{
|
||
doc.Delete(tempBranchConnector.GetConnectedConnector().Owner.Id);
|
||
}
|
||
|
||
doc.Delete(verticalMEPCurveId);
|
||
//三通中未连接的连接件即分支连接件
|
||
Connector teeBranchConn = tee.GetConnectors(true).OfType<Connector>().FirstOrDefault();
|
||
try
|
||
{
|
||
//设置三通角度
|
||
teeBranchConn!.Angle = Math.PI - angle;
|
||
}
|
||
catch (Autodesk.Revit.Exceptions.InvalidOperationException)
|
||
{
|
||
Debug.WriteLine("无法修改管线角度");
|
||
}
|
||
|
||
doc.Regenerate();
|
||
//Connector branchFarConn = branch.Owner.GetConnectors().GetFarthestConnector(intersect);
|
||
//Line newBranch = Line.CreateBound(branchFarConn.Origin, teeBranchConn.Origin);
|
||
Line l = branch.Owner.GetLocCurve() as Line;
|
||
Line newBranchLine = l.ExtendLine(teeBranchConn!.Origin);
|
||
branch.Owner.SetLocationCurve(newBranchLine);
|
||
//Line line = branch.Owner.GetLocCurve() 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();
|
||
//}
|
||
Connector newBranchConn = GetNearestConnector(branch.Owner.GetConnectors(), intersect);
|
||
newBranchConn.ConnectByFitting(teeBranchConn);
|
||
return tee;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 新建视图并设置剖切框
|
||
在此之后:
|
||
/// 新建视图并设置剖切框
|
||
*/
|
||
|
||
/// <summary>
|
||
/// 新建视图并设置剖切框
|
||
/// </summary>
|
||
/// <param name="doc"></param>
|
||
/// <param name="view3D">复制的三维视图</param>
|
||
/// <param name="elementIds"></param>
|
||
/// <returns></returns>
|
||
public static View3D CreateSectionBox(this View3D view3D, IEnumerable<ElementId> elementIds, bool inCurrentView)
|
||
{
|
||
var doc = view3D.Document;
|
||
XYZ extendXyz = new(1, 1, 1);
|
||
BoundingBoxXYZ b;
|
||
if (elementIds.Count() == 1)
|
||
{
|
||
var e = doc.GetElement(elementIds.FirstOrDefault());
|
||
b = e.get_BoundingBox(view3D);
|
||
var max = b.Max + extendXyz;
|
||
var min = b.Min - extendXyz;
|
||
b = new BoundingBoxXYZ { Max = max, Min = min };
|
||
}
|
||
else
|
||
{
|
||
var f = doc.GetElement(elementIds.FirstOrDefault(elem => doc.GetElement(elem).get_BoundingBox(view3D) != null));
|
||
b = f.get_BoundingBox(view3D);
|
||
|
||
var maxX = b.Max.X;
|
||
var maxY = b.Max.Y;
|
||
var maxZ = b.Max.Z;
|
||
var minX = b.Min.X;
|
||
var minY = b.Min.Y;
|
||
var minZ = b.Min.Z;
|
||
foreach (var elementId in elementIds)
|
||
{
|
||
var e = doc.GetElement(elementId);
|
||
var bb = e.get_BoundingBox(doc.ActiveView);
|
||
|
||
if (bb.Max.X >= maxX)
|
||
{
|
||
maxX = bb.Max.X;
|
||
}
|
||
|
||
if (bb.Max.Y >= maxY)
|
||
{
|
||
maxY = bb.Max.Y;
|
||
}
|
||
|
||
if (bb.Max.Z >= maxZ)
|
||
{
|
||
maxZ = bb.Max.Z;
|
||
}
|
||
|
||
if (bb.Min.X <= minX)
|
||
{
|
||
minX = bb.Min.X;
|
||
}
|
||
|
||
if (bb.Min.Y <= minY)
|
||
{
|
||
minY = bb.Min.Y;
|
||
}
|
||
|
||
if (bb.Min.Z <= minZ)
|
||
{
|
||
minZ = bb.Min.Z;
|
||
}
|
||
}
|
||
|
||
var max = new XYZ(maxX, maxY, maxZ) + extendXyz;
|
||
var min = new XYZ(minX, minY, minZ) - extendXyz;
|
||
b = new BoundingBoxXYZ { Max = max, Min = min };
|
||
}
|
||
|
||
if (!view3D.IsSectionBoxActive)
|
||
{
|
||
view3D.IsSectionBoxActive = true;
|
||
}
|
||
|
||
if (inCurrentView)
|
||
{
|
||
view3D.SetSectionBox(b);
|
||
return view3D;
|
||
}
|
||
|
||
var viewCopyId = view3D.Duplicate(ViewDuplicateOption.WithDetailing);
|
||
var viewCopy = doc.GetElement(viewCopyId) as View3D;
|
||
viewCopy?.SetSectionBox(b);
|
||
return viewCopy;
|
||
}
|
||
|
||
public static double Distance(this Line line1, Line line2)
|
||
{
|
||
double distance;
|
||
|
||
var v1 = line1.Direction;
|
||
var p1 = line1.GetEndPoint(0);
|
||
var v2 = line2.Direction;
|
||
var p2 = line2.GetEndPoint(0);
|
||
|
||
var a = p1.X - p2.X;
|
||
var b = p1.Y - p2.Y;
|
||
var c = p1.Z - p2.Z;
|
||
var pq = v1.X * v2.Y - v2.X * v1.Y;
|
||
var qr = v1.Y * v2.Z - v2.Y * v1.Z;
|
||
var rp = v1.Z * v2.X - v2.Z * v1.X;
|
||
var dev = Math.Sqrt(Math.Pow(qr, 2) + Math.Pow(rp, 2) + Math.Pow(pq, 2));
|
||
|
||
if (dev < 1e-9)
|
||
{
|
||
var bp = b * v1.X;
|
||
var br = b * v1.Z;
|
||
var cp = c * v1.X;
|
||
var cq = c * v1.Y;
|
||
var aq = a * v1.Y;
|
||
var ar = a * v1.Z;
|
||
distance =
|
||
Math.Sqrt(Math.Pow(br - cq, 2) + Math.Pow(cp - ar, 2) + Math.Pow(aq - bp, 2))
|
||
/ Math.Sqrt(Math.Pow(v1.X, 2) + Math.Pow(v1.Y, 2) + Math.Pow(v1.Z, 2));
|
||
}
|
||
else
|
||
{
|
||
distance = Math.Abs((qr * a + rp * b + pq * c) / dev);
|
||
}
|
||
|
||
return distance;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 延长或缩短直线
|
||
/// </summary>
|
||
/// <param name="line"></param>
|
||
/// <param name="endPoint"></param>
|
||
/// <param name="startSection">保留部分，为空时，保留长的部分</param>
|
||
/// <returns></returns>
|
||
public static Line ExtendLine(this Line line, XYZ endPoint, bool? startSection = null)
|
||
{
|
||
var v = endPoint - line.GetEndPoint(0);
|
||
var v2 = endPoint - line.GetEndPoint(1);
|
||
//点刚好是直线端点
|
||
if (v.IsZeroLength() || v2.IsZeroLength())
|
||
{
|
||
return line;
|
||
}
|
||
//必须平行才能延伸
|
||
|
||
if (v.IsParallelTo(v2))
|
||
{
|
||
//点在直线外，同方向
|
||
if (line.Direction.DotProduct(v) > 0.0 && line.Direction.DotProduct(v2) > 0.0)
|
||
{
|
||
return Line.CreateBound(line.GetEndPoint(0), endPoint);
|
||
}
|
||
|
||
//点在直线外，反方向
|
||
if (line.Direction.DotProduct(v) < 0.0 && line.Direction.DotProduct(v2) < 0.0)
|
||
{
|
||
return Line.CreateBound(endPoint, line.GetEndPoint(1));
|
||
}
|
||
|
||
//点在直线内
|
||
return v.DotProduct(v2) < 0.0
|
||
? startSection == null
|
||
? v.GetLength() >= v2.GetLength()
|
||
? Line.CreateBound(line.GetEndPoint(0), endPoint)
|
||
: Line.CreateBound(endPoint, line.GetEndPoint(1))
|
||
: startSection == true
|
||
? Line.CreateBound(line.GetEndPoint(0), endPoint)
|
||
: Line.CreateBound(endPoint, line.GetEndPoint(1))
|
||
: null;
|
||
}
|
||
|
||
return line;
|
||
//throw new InvalidOperationException("不可延伸到该点");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 延长直线
|
||
/// </summary>
|
||
/// <param name="line"></param>
|
||
/// <param name="distance"></param>
|
||
/// <param name="isInteractive">是否双向延申，单向延长终点</param>
|
||
/// <returns></returns>
|
||
public static Line ExtendLine(this Line line, double distance, bool isInteractive = false)
|
||
{
|
||
var endPoint = line.GetEndPoint(1) + line.Direction * distance;
|
||
var startPoint = line.GetEndPoint(0);
|
||
if (isInteractive)
|
||
{
|
||
startPoint += line.Direction.Negate() * distance;
|
||
}
|
||
|
||
return Line.CreateBound(startPoint, endPoint);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点拍平到xy平面
|
||
/// </summary>
|
||
/// <param name="xyz"></param>
|
||
/// <returns></returns>
|
||
public static XYZ Flatten(this XYZ xyz)
|
||
{
|
||
return xyz.Subtract(XYZ.BasisZ * xyz.Z);
|
||
}
|
||
/// <summary>
|
||
/// 点拍平到标高平面
|
||
/// </summary>
|
||
/// <param name="xyz"></param>
|
||
/// <returns></returns>
|
||
public static XYZ FlattenTo(this XYZ xyz, Level level)
|
||
{
|
||
var z = level.Elevation;
|
||
|
||
return xyz.Add(XYZ.BasisZ * (z - xyz.Z));
|
||
}
|
||
/// <summary>
|
||
/// 获取块参照实例
|
||
/// </summary>
|
||
/// <param name="dwg"></param>
|
||
/// <param name="reference"></param>
|
||
/// <returns></returns>
|
||
public static List<GeometryInstance> GetBlockInstance(this ImportInstance dwg, Reference reference)
|
||
{
|
||
var geoElem = dwg.get_Geometry(new Options());
|
||
|
||
var geoObj = dwg.GetGeometryObjectFromReference(reference);
|
||
GeometryInstance referBlock = null;
|
||
foreach (var obj in geoElem)
|
||
{
|
||
if (obj is GeometryInstance dwgGeo) //dwg几何实例
|
||
{
|
||
foreach (var block in dwgGeo.SymbolGeometry) //块
|
||
{
|
||
if (block is GeometryInstance ins)
|
||
{
|
||
if (ins.GetHashCode() == geoObj.GetHashCode())
|
||
{
|
||
referBlock = ins;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
foreach (var subBlock in ins.SymbolGeometry) //嵌套块/子块
|
||
{
|
||
if (subBlock is GeometryInstance subIns && subIns.GetHashCode() == geoObj.GetHashCode())
|
||
{
|
||
referBlock = ins;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (referBlock == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
List<GeometryInstance> blocks = [];
|
||
foreach (var obj in geoElem)
|
||
{
|
||
if (obj is GeometryInstance dwgGeo)
|
||
{
|
||
foreach (var block in dwgGeo.SymbolGeometry) //图元
|
||
{
|
||
if (block is GeometryInstance ins && ins.Symbol.Name == referBlock.Symbol.Name)
|
||
{
|
||
blocks.Add(ins);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return blocks;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 得到元素所有连接件
|
||
/// </summary>
|
||
/// <param name="element"></param>
|
||
/// <param name="isUnused">获取未使用的连接件，否则获取全部</param>
|
||
/// <returns></returns>
|
||
public static ConnectorSet GetConnectors(this Element element, bool isUnused = false)
|
||
{
|
||
var connectorSet = new ConnectorSet();
|
||
switch (element)
|
||
{
|
||
case FamilyInstance familyInstance:
|
||
connectorSet = isUnused
|
||
? familyInstance.MEPModel.ConnectorManager?.UnusedConnectors
|
||
: familyInstance.MEPModel?.ConnectorManager?.Connectors;
|
||
break;
|
||
case MEPCurve mepCurve:
|
||
connectorSet = isUnused ? mepCurve.ConnectorManager.UnusedConnectors : mepCurve.ConnectorManager.Connectors;
|
||
break;
|
||
case FabricationPart fabricationPart:
|
||
connectorSet = isUnused ? fabricationPart.ConnectorManager.UnusedConnectors : fabricationPart.ConnectorManager.Connectors;
|
||
break;
|
||
}
|
||
|
||
return connectorSet;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取dwg的曲线
|
||
/// </summary>
|
||
/// <param name="importInstance"></param>
|
||
/// <returns></returns>
|
||
public static List<Curve> GetCurves(this ImportInstance importInstance)
|
||
{
|
||
List<Curve> curves = [];
|
||
var geoElem = importInstance.get_Geometry(new Options());
|
||
foreach (var geomObj in geoElem)
|
||
{
|
||
var geomInstance = geomObj as GeometryInstance;
|
||
|
||
if (geomInstance != null)
|
||
{
|
||
foreach (var instObj in geomInstance.GetInstanceGeometry())
|
||
{
|
||
//polyLine拆成线
|
||
if (instObj is PolyLine line)
|
||
{
|
||
var poly = line.GetCoordinates();
|
||
for (var i = 0; i < poly.Count - 1; i++)
|
||
{
|
||
var l = Line.CreateBound(poly[i], poly[i + 1]);
|
||
curves.Add(l);
|
||
}
|
||
}
|
||
|
||
if (instObj is Arc arc)
|
||
{
|
||
curves.Add(arc);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return curves;
|
||
}
|
||
public static ElementId GetElementId(this BuiltInCategory builtInCategory, Document doc)
|
||
{
|
||
return Category.GetCategory(doc, builtInCategory).Id;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 获取顶层的几何（非嵌套）
|
||
/// </summary>
|
||
/// <typeparam name="T"></typeparam>
|
||
/// <param name="elem"></param>
|
||
/// <returns></returns>
|
||
public static List<GeometryObject> GetGeometryObjects(this Element elem)
|
||
{
|
||
List<GeometryObject> geometryObjects = [];
|
||
Options option = new() { ComputeReferences = true, DetailLevel = ViewDetailLevel.Fine };
|
||
var geometry = elem.get_Geometry(option);
|
||
|
||
foreach (var geomObj in geometry)
|
||
{
|
||
geometryObjects.Add(geomObj);
|
||
}
|
||
|
||
return geometryObjects;
|
||
}
|
||
/// <summary>
|
||
/// 获取几何对象
|
||
/// </summary>
|
||
/// <typeparam name="T">对应类型的几何对象，如Solid、Face、Edge</typeparam>
|
||
/// <param name="elem">获取的元素</param>
|
||
/// <returns></returns>
|
||
public static List<T> GetGeometryObjects<T>(this Element elem)
|
||
where T : GeometryObject
|
||
{
|
||
List<T> geometryObjects = [];
|
||
Options option = new() { ComputeReferences = true, DetailLevel = ViewDetailLevel.Fine };
|
||
var geometry = elem.get_Geometry(option);
|
||
|
||
foreach (var geomObj in geometry)
|
||
{
|
||
if (geomObj is GeometryInstance geomInstance)
|
||
{
|
||
var usesSymbolGeometry = elem is FamilyInstance instance && !instance.HasModifiedGeometry();
|
||
var geometryElement = usesSymbolGeometry ? geomInstance.GetSymbolGeometry() : geomInstance.GetInstanceGeometry();
|
||
|
||
foreach (var geoObject in geometryElement)
|
||
{
|
||
geometryObjects.AddRange(geoObject.GetGeoObjects<T>());
|
||
}
|
||
}
|
||
|
||
geometryObjects.AddRange(geomObj.GetGeoObjects<T>());
|
||
}
|
||
|
||
return geometryObjects;
|
||
}
|
||
/// <summary>
|
||
/// 获取参考所在的图层名称
|
||
/// </summary>
|
||
/// <param name="dwg"></param>
|
||
/// <param name="reference"></param>
|
||
/// <returns></returns>
|
||
public static string GetLayerName(this ImportInstance dwg, Reference reference)
|
||
{
|
||
var obj = dwg.GetGeometryObjectFromReference(reference);
|
||
var style = dwg.Document.GetElement(obj.GraphicsStyleId) as GraphicsStyle;
|
||
return style?.GraphicsStyleCategory.Name;
|
||
}
|
||
/// <summary>
|
||
/// 获取标高
|
||
/// </summary>
|
||
/// <param name="model"></param>
|
||
/// <returns></returns>
|
||
public static ElementId GetLevelId(this Element model)
|
||
{
|
||
// 定义需要检查的参数列表
|
||
var parametersToCheck = new BuiltInParameter[]
|
||
{
|
||
BuiltInParameter.WALL_BASE_CONSTRAINT, // 墙
|
||
BuiltInParameter.SCHEDULE_BASE_LEVEL_PARAM, // 柱子标高
|
||
BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM, // 梁标高
|
||
BuiltInParameter.STAIRS_BASE_LEVEL_PARAM, // 楼梯标高
|
||
BuiltInParameter.INSTANCE_ELEVATION_PARAM, // 族实例明细表标高
|
||
BuiltInParameter.ROOF_CONSTRAINT_LEVEL_PARAM,//屋顶
|
||
BuiltInParameter.INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM,// 族实例明细表标高
|
||
BuiltInParameter.RBS_START_LEVEL_PARAM// 管线标高
|
||
};
|
||
// 依次检查每个参数
|
||
foreach (var param in parametersToCheck)
|
||
{
|
||
var baseLevelId = model.get_Parameter(param)?.AsElementId();
|
||
if (baseLevelId != ElementId.InvalidElementId && baseLevelId != null)
|
||
{
|
||
return baseLevelId;
|
||
}
|
||
}
|
||
|
||
//最后检查楼板或族基准标高
|
||
return model.LevelId;
|
||
}
|
||
/// <summary>
|
||
/// 获取元素定位线
|
||
/// </summary>
|
||
/// <param name="instance">以曲线定位的实例</param>
|
||
/// <returns></returns>
|
||
public static Curve GetLocCurve(this Element instance)
|
||
{
|
||
return instance.Location is LocationCurve lc ? lc.Curve : null;
|
||
}
|
||
/// <summary>
|
||
/// 获取元素定位点
|
||
/// </summary>
|
||
/// <param name="instance">以点定位的实例</param>
|
||
/// <returns></returns>
|
||
public static XYZ GetLocXYZ(this Element instance)
|
||
{
|
||
return instance.Location is LocationPoint lc ? lc.Point : null;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 同专业类型的最近连接件
|
||
/// </summary>
|
||
/// <param name="element1"></param>
|
||
/// <param name="element2"></param>
|
||
/// <param name="isUnused"></param>
|
||
/// <returns></returns>
|
||
public static List<Connector> GetNearestDomainConnectors(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;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 计算两条线的交点
|
||
/// </summary>
|
||
/// <param name="curve1"></param>
|
||
/// <param name="curve2"></param>
|
||
/// <returns></returns>
|
||
public static XYZ IntersectionPoint(this Curve curve1, Curve curve2)
|
||
{
|
||
var comparisonR = curve1.Intersect(curve2, out var intersectionR);
|
||
XYZ intersectionResult = null;
|
||
if (SetComparisonResult.Disjoint != comparisonR) // Disjoint无交点
|
||
{
|
||
try
|
||
{
|
||
if (intersectionR != null && !intersectionR.IsEmpty)
|
||
{
|
||
intersectionResult = intersectionR.get_Item(0).XYZPoint;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
}
|
||
|
||
return intersectionResult;
|
||
}
|
||
public static XYZ IntersectPoint(this Plane plane, Line line)
|
||
{
|
||
var startPoint = line.Origin;
|
||
|
||
var projectPoint = plane.ProjectOnto(startPoint);
|
||
if (Math.Abs(line.Direction.DotProduct(plane.Normal)) < 10E-8) //是否平行
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var length = startPoint.DistanceTo(projectPoint);
|
||
if (length < 10E-8) //不平行，但刚好是Origin,即为交点
|
||
{
|
||
return projectPoint;
|
||
}
|
||
|
||
var vector = projectPoint - startPoint;
|
||
//var per = Line.CreateBound(startPoint, projectPoint);//垂线
|
||
if (vector.IsParallelTo(line.Direction))
|
||
{
|
||
return projectPoint;
|
||
}
|
||
|
||
var cos = plane.Normal.DotProduct(line.Direction);
|
||
if (cos < 0)
|
||
{
|
||
cos = plane.Normal.Negate().DotProduct(line.Direction);
|
||
}
|
||
|
||
var distance = length / cos;
|
||
return vector.Normalize().DotProduct(line.Direction) < 0
|
||
? startPoint - line.Direction * distance
|
||
: startPoint + line.Direction * distance;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点是否在直线范围内
|
||
/// </summary>
|
||
/// <param name="line"></param>
|
||
/// <param name="point"></param>
|
||
/// <param name="endParameter">两边端点距离</param>
|
||
/// <returns></returns>
|
||
public static bool IsInsideEx(this Line line, XYZ point, double endParameter = 0.0)
|
||
{
|
||
var flag = line == null;
|
||
if (flag)
|
||
{
|
||
throw new ArgumentNullException(nameof(line));
|
||
}
|
||
|
||
var isBound = line.IsBound;
|
||
bool result;
|
||
if (isBound)
|
||
{
|
||
var d = point.DistanceTo(line.GetEndPoint(0));
|
||
var d2 = point.DistanceTo(line.GetEndPoint(1));
|
||
result = d + d2 - line.Length < 1E-05 && d >= endParameter && d2 >= endParameter;
|
||
}
|
||
else
|
||
{
|
||
result = false;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判断直线是否平行或重合
|
||
/// </summary>
|
||
/// <param name="line"></param>
|
||
/// <param name="checkedLine"></param>
|
||
/// <returns></returns>
|
||
public static bool IsParallelTo(this Line line, Line checkedLine)
|
||
{
|
||
var a = line.Direction.CrossProduct(checkedLine.Direction).IsZeroLength();
|
||
var b = line.Direction.CrossProduct(checkedLine.Direction).IsAlmostEqualTo(XYZ.Zero);
|
||
var c = 1 - Math.Abs(line.Direction.DotProduct(checkedLine.Direction)) < Tolerance;
|
||
return a || b || c;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判断方向是否平行
|
||
/// </summary>
|
||
/// <param name="direction1"></param>
|
||
/// <param name="direction2"></param>
|
||
/// <returns></returns>
|
||
public static bool IsParallelTo(this XYZ direction1, XYZ direction2)
|
||
{
|
||
return direction1.CrossProduct(direction2).IsZeroLength() || direction1.CrossProduct(direction2).IsAlmostEqualTo(XYZ.Zero);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判断直线是否垂直
|
||
/// </summary>
|
||
/// <param name="line"></param>
|
||
/// <param name="checkedLine"></param>
|
||
/// <param name="tolerance"></param>
|
||
/// <returns></returns>
|
||
public static bool IsPerpendicularTo(this Line line, Line checkedLine, double tolerance = Tolerance)
|
||
{
|
||
return Math.Abs(line.Direction.DotProduct(checkedLine.Direction)) < tolerance; //点乘满足交换律不影响计算结果
|
||
}
|
||
|
||
/// <summary>
|
||
/// 直线在平面上的投影
|
||
/// </summary>
|
||
/// <param name="plane"></param>
|
||
/// <param name="line"></param>
|
||
/// <returns></returns>
|
||
public static Line ProjectOnto(this Plane plane, Line line)
|
||
{
|
||
return Line.CreateBound(plane.ProjectOnto(line.GetEndPoint(0)), plane.ProjectOnto(line.GetEndPoint(1)));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点在几何面的投影
|
||
/// </summary>
|
||
/// <param name="plane"></param>
|
||
/// <param name="p"></param>
|
||
/// <returns></returns>
|
||
public static XYZ ProjectOnto(this PlanarFace plane, XYZ p)
|
||
{
|
||
var d = plane.SignedDistanceTo(p, out _);
|
||
var q = p - d * plane.FaceNormal;
|
||
|
||
return q;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点在参照平面上的投影
|
||
/// </summary>
|
||
/// <param name="plane"></param>
|
||
/// <param name="p"></param>
|
||
/// <returns></returns>
|
||
public static XYZ ProjectOnto(this Plane plane, XYZ p)
|
||
{
|
||
var d = plane.SignedDistanceTo(p, out _);
|
||
var q = p - d * plane.Normal;
|
||
|
||
return q;
|
||
}
|
||
public static void SetBorderColor(this Element element, Color color, View view = null)
|
||
{
|
||
var doc = element.Document;
|
||
|
||
view ??= doc.ActiveView;
|
||
var overrideGraphicSettings = view.GetElementOverrides(element.Id);
|
||
var pat = new FilteredElementCollector(doc)
|
||
.OfClass(typeof(FillPatternElement))
|
||
.ToElements()
|
||
.Cast<FillPatternElement>()
|
||
.Where(pattern =>
|
||
{
|
||
var fill = pattern.GetFillPattern();
|
||
return fill.Target == FillPatternTarget.Drafting
|
||
&& fill.HostOrientation == FillPatternHostOrientation.ToView
|
||
&& fill.IsSolidFill;
|
||
})
|
||
.FirstOrDefault();
|
||
overrideGraphicSettings.SetProjectionLineColor(color);
|
||
overrideGraphicSettings.SetCutLineColor(color);
|
||
view.SetElementOverrides(element.Id, overrideGraphicSettings);
|
||
|
||
}
|
||
public static void SetFillColor(this Element element, Color color, View view = null)
|
||
{
|
||
var doc = element.Document;
|
||
|
||
view ??= doc.ActiveView;
|
||
var overrideGraphicSettings = view.GetElementOverrides(element.Id);
|
||
var pat = new FilteredElementCollector(doc)
|
||
.OfClass(typeof(FillPatternElement))
|
||
.ToElements()
|
||
.Cast<FillPatternElement>()
|
||
.Where(pattern =>
|
||
{
|
||
var fill = pattern.GetFillPattern();
|
||
return fill.Target == FillPatternTarget.Drafting
|
||
&& fill.HostOrientation == FillPatternHostOrientation.ToView
|
||
&& fill.IsSolidFill;
|
||
})
|
||
.FirstOrDefault();
|
||
#if REVIT2018
|
||
overrideGraphicSettings.SetProjectionFillPatternId(pat.Id);
|
||
overrideGraphicSettings.SetProjectionLineColor(color);
|
||
overrideGraphicSettings.SetCutFillPatternId(pat.Id);
|
||
overrideGraphicSettings.SetCutLineColor(color);
|
||
view.SetElementOverrides(element.Id, overrideGraphicSettings);
|
||
#elif REVIT2020
|
||
|
||
overrideGraphicSettings.SetSurfaceForegroundPatternColor(color);
|
||
overrideGraphicSettings.SetSurfaceForegroundPatternId(pat.Id); //实体填充
|
||
overrideGraphicSettings.SetCutForegroundPatternColor(color);
|
||
overrideGraphicSettings.SetCutForegroundPatternId(pat.Id); //实体填充
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置元素定位线
|
||
/// </summary>
|
||
/// <param name="instance"></param>
|
||
/// <param name="curve"></param>
|
||
/// <returns></returns>
|
||
public static void SetLocationCurve(this Element instance, Curve curve)
|
||
{
|
||
if (instance == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(instance));
|
||
}
|
||
|
||
if (curve == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(curve));
|
||
}
|
||
|
||
if (instance.Location is LocationCurve lc)
|
||
{
|
||
try
|
||
{
|
||
lc.Curve = curve;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
throw new InvalidOperationException("无法修改定位线");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点与几何平面的距离(可正可负)
|
||
/// </summary>
|
||
/// <param name="plane"></param>
|
||
/// <param name="p"></param>
|
||
/// <param name="projectPoint"></param>
|
||
/// <returns></returns>
|
||
public static double SignedDistanceTo(this PlanarFace plane, XYZ p, out XYZ projectPoint)
|
||
{
|
||
var v = p - plane.Origin;
|
||
//垂向距离（可正可负,夹角钝角为负）
|
||
var perp = v.DotProduct(plane.FaceNormal);
|
||
projectPoint = p - perp * plane.FaceNormal;
|
||
return perp;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 点与平面的距离(可正可负)
|
||
/// </summary>
|
||
/// <param name="plane"></param>
|
||
/// <param name="p"></param>
|
||
/// <param name="projectPoint"></param>
|
||
/// <returns></returns>
|
||
public static double SignedDistanceTo(this Plane plane, XYZ p, out XYZ projectPoint)
|
||
{
|
||
var v = p - plane.Origin;
|
||
//垂向距离（可正可负,夹角钝角为负）
|
||
var perp = v.DotProduct(plane.Normal);
|
||
projectPoint = p - perp * plane.Normal;
|
||
return perp;
|
||
}
|
||
public static BuiltInCategory ToBuiltInCategory(this Category category)
|
||
{
|
||
var builtInCategory = (BuiltInCategory)category.Id.IntegerValue;
|
||
|
||
return Enum.IsDefined(typeof(BuiltInCategory), builtInCategory)
|
||
? builtInCategory
|
||
: throw new ArgumentNullException(nameof(category), "不存在该内建类别");
|
||
}
|
||
public static Element ToElement(this ElementId id, Document doc)
|
||
{
|
||
return doc.GetElement(id);
|
||
}
|
||
}
|