727 lines
30 KiB
C#
727 lines
30 KiB
C#
using Autodesk.Revit.Attributes;
|
||
using Autodesk.Revit.DB;
|
||
using Autodesk.Revit.UI;
|
||
|
||
using Nice3point.Revit.Toolkit.External;
|
||
|
||
using System;
|
||
using System.Globalization;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using System.Windows;
|
||
|
||
using System.Windows.Media;
|
||
|
||
namespace Szmedi.RvKits.DrawingTools
|
||
{
|
||
[Transaction(TransactionMode.Manual)]
|
||
|
||
public class DimensionView3dCmd : ExternalCommand
|
||
{
|
||
public override void Execute()
|
||
{
|
||
ViewFamilyType viewFamilyType = new FilteredElementCollector(Document)
|
||
.OfClass(typeof(ViewFamilyType))
|
||
.Cast<ViewFamilyType>()
|
||
.FirstOrDefault(t => t.ViewFamily == ViewFamily.ThreeDimensional);
|
||
IEnumerable<Grid> grids = new FilteredElementCollector(Document).OfClass(typeof(Grid)).Cast<Grid>();
|
||
View3D myView = null;
|
||
int n = 100;
|
||
if (!grids.Any())
|
||
{
|
||
Result = Result.Cancelled;
|
||
return;
|
||
}
|
||
Document.Invoke(
|
||
_ =>
|
||
{
|
||
if (viewFamilyType != null)
|
||
{
|
||
myView = View3D.CreateIsometric(Document, viewFamilyType.Id);
|
||
}
|
||
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
try
|
||
{
|
||
myView.Name = $"三维轴测视图_{i}";
|
||
break;
|
||
}
|
||
catch (Autodesk.Revit.Exceptions.ArgumentException) { }
|
||
}
|
||
|
||
myView.SaveOrientationAndLock();
|
||
List<ModelCurve> mcurves = Create3dGrid(myView, grids);
|
||
Document.Regenerate();
|
||
CreateDimension(Document, myView, mcurves);
|
||
},
|
||
"三维标注"
|
||
);
|
||
|
||
UiDocument.ActiveView = myView;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取族实例所有面(实际为族类型的所有面)
|
||
/// </summary>
|
||
/// <param name="instance"></param>
|
||
/// <param name="options"></param>
|
||
/// <returns></returns>
|
||
public static List<Face> GetFacesByFamilyInstance(FamilyInstance instance, Options options)
|
||
{
|
||
List<Face> faces = new();
|
||
//根据打开的方式得到几何信息
|
||
GeometryElement geometry = instance.get_Geometry(options);
|
||
foreach (GeometryObject geomObj in geometry)
|
||
{
|
||
//geomObj为几何实例
|
||
GeometryInstance geomInstance = geomObj as GeometryInstance;
|
||
if (geomInstance == null)
|
||
{
|
||
continue;
|
||
}
|
||
//族实例未修改过（连接，剪切，复制，扩展）
|
||
bool usesSymbolGeometry = instance is not null && !instance.HasModifiedGeometry();
|
||
bool bo = instance.HasModifiedGeometry();
|
||
GeometryElement instanceGeometry = usesSymbolGeometry
|
||
? geomInstance.GetSymbolGeometry()
|
||
: geomInstance.GetInstanceGeometry();
|
||
|
||
if (instanceGeometry != null)
|
||
{
|
||
//instanceGeometry.GetTransformed();
|
||
//从实例中找到实例的几何体
|
||
foreach (GeometryObject instObj in instanceGeometry)
|
||
{
|
||
//三维的实体
|
||
Solid instSolid = instObj as Solid;
|
||
if (instSolid == null || instSolid.Faces.Size == 0 || instSolid.Edges.Size == 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (Face face in instSolid.Faces)
|
||
{
|
||
faces.Add(face);
|
||
}
|
||
}
|
||
}
|
||
|
||
//geomObj为几何体
|
||
Solid solid = geomObj as Solid;
|
||
if (solid != null)
|
||
{
|
||
if (solid.Faces.Size == 0 || solid.Edges.Size == 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (Face face in solid.Faces)
|
||
{
|
||
faces.Add(face);
|
||
}
|
||
}
|
||
}
|
||
|
||
return faces;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取元素侧面
|
||
/// </summary>
|
||
/// <param name="elem"></param>
|
||
/// <returns></returns>
|
||
public static List<Face> GetSideFacesByElement(Element elem)
|
||
{
|
||
Options opt = new() { ComputeReferences = true, DetailLevel = ViewDetailLevel.Fine };
|
||
GeometryElement ge = elem.get_Geometry(opt);
|
||
List<Face> lstpf = new();
|
||
foreach (GeometryObject obj in ge)
|
||
{
|
||
Solid solid = obj as Solid;
|
||
if (solid != null)
|
||
{
|
||
foreach (Face face in solid.Faces)
|
||
{
|
||
PlanarFace pf = face as PlanarFace;
|
||
if (pf != null)
|
||
{
|
||
//点乘，即面的法向与Z轴始终垂直
|
||
double dotp = pf.FaceNormal.DotProduct(XYZ.BasisZ);
|
||
if (dotp is < 1.0e-09 and > (-1.0e-09)) //近似为0
|
||
{
|
||
lstpf.Add(pf);
|
||
}
|
||
//if (pf.FaceNormal.CrossProduct(wall.Orientation).IsZeroLength())
|
||
//{
|
||
// lstpf.Add(pf);
|
||
//}
|
||
}
|
||
|
||
CylindricalFace cy = face as CylindricalFace;
|
||
if (cy != null)
|
||
{
|
||
lstpf.Add(cy);
|
||
}
|
||
}
|
||
|
||
return lstpf;
|
||
}
|
||
}
|
||
|
||
return lstpf;
|
||
}
|
||
|
||
private List<ModelCurve> Create3dGrid(View view, IEnumerable<Grid> grids)
|
||
{
|
||
Document Document = view.Document;
|
||
List<TextNoteType> textnotetypes = new FilteredElementCollector(Document)
|
||
.OfClass(typeof(TextNoteType))
|
||
.Cast<TextNoteType>()
|
||
.ToList();
|
||
TextNoteType textnotetype = textnotetypes.FirstOrDefault();
|
||
List<ModelCurve> curves = new();
|
||
IEnumerable<bool> gridGroups = grids
|
||
.GroupBy(g => g.Curve.ComputeDerivatives(0, true).BasisX.Normalize().X)
|
||
.Select(s => s.Count() > 1);
|
||
|
||
Plane plane = Plane.CreateByOriginAndBasis(XYZ.Zero, XYZ.BasisX, XYZ.BasisY);
|
||
SketchPlane sketch = SketchPlane.Create(Document, plane);
|
||
|
||
foreach (Grid grid in grids)
|
||
{
|
||
Curve curve = grid.Curve;
|
||
XYZ startp = curve.GetEndPoint(0);
|
||
XYZ endp = curve.GetEndPoint(1);
|
||
|
||
int radius = 2;
|
||
XYZ direction = curve.ComputeDerivatives(0, true).BasisX.Normalize().Negate();
|
||
XYZ direction1 = curve.ComputeDerivatives(1, true).BasisX.Normalize();
|
||
SketchPlane gridSketch = SketchPlane.Create(Document, new Reference(grid));
|
||
XYZ loc = startp + (direction * radius);
|
||
XYZ loc1 = endp + (direction1 * radius);
|
||
|
||
Arc circle = Arc.Create(loc, radius, 0, Math.PI * 2, XYZ.BasisX, XYZ.BasisY);
|
||
Arc circle1 = Arc.Create(loc1, radius, 0, Math.PI * 2, XYZ.BasisX, XYZ.BasisY);
|
||
|
||
TextNoteOptions options =
|
||
new(textnotetype.Id)
|
||
{
|
||
HorizontalAlignment = HorizontalTextAlignment.Center,
|
||
#if REVIT2019 || REVIT2020
|
||
VerticalAlignment = VerticalTextAlignment.Middle
|
||
#endif
|
||
};
|
||
//Text.FromStringOriginAndScale(grid.Name, loc, size);
|
||
//Text.FromStringOriginAndScale(grid.Name, loc1, size);
|
||
TextNote.Create(Document, view.Id, loc, grid.Name, options);
|
||
TextNote.Create(Document, view.Id, loc1, grid.Name, options);
|
||
|
||
ModelCurve gridLine = Document.Create.NewModelCurve(grid.Curve, gridSketch);
|
||
Document.Create.NewModelCurve(circle, sketch);
|
||
Document.Create.NewModelCurve(circle1, sketch);
|
||
curves.Add(gridLine);
|
||
}
|
||
|
||
return curves;
|
||
}
|
||
|
||
internal static MethodInfo GenerateTransientDisplayMethod()
|
||
{
|
||
Type geometryElementType = typeof(GeometryElement);
|
||
MethodInfo[] geometryElementTypeMethods = geometryElementType.GetMethods(
|
||
BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic
|
||
);
|
||
MethodInfo method = geometryElementTypeMethods.FirstOrDefault(x => x.Name == "SetForTransientDisplay");
|
||
return method;
|
||
}
|
||
|
||
private ReferenceArray RemoveZeroSegements(Wall wall, ReferenceArray wallLengthRefernceArray, Dimension lengthdim)
|
||
{
|
||
List<Reference> referencesdelete = new();
|
||
ReferenceArray finallengthreferenceArray = new();
|
||
for (int i = 0; i < lengthdim.NumberOfSegments; i++)
|
||
{
|
||
if (lengthdim.Segments.get_Item(i).ValueString == "0")
|
||
{
|
||
if (lengthdim.References.get_Item(i).ElementId == wall.Id)
|
||
{
|
||
referencesdelete.Add(lengthdim.References.get_Item(i));
|
||
}
|
||
|
||
if (lengthdim.References.get_Item(i + 1).ElementId == wall.Id)
|
||
{
|
||
referencesdelete.Add(lengthdim.References.get_Item(i + 1));
|
||
}
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < wallLengthRefernceArray.Size; i++)
|
||
{
|
||
bool isContain = false;
|
||
Reference reference = wallLengthRefernceArray.get_Item(i);
|
||
foreach (Reference referdelete in referencesdelete)
|
||
{
|
||
if (reference.EqualTo(referdelete))
|
||
{
|
||
isContain = true;
|
||
}
|
||
}
|
||
|
||
if (!isContain)
|
||
{
|
||
finallengthreferenceArray.Append(reference);
|
||
}
|
||
}
|
||
|
||
return finallengthreferenceArray;
|
||
}
|
||
|
||
public void CreateBeamsDimension(Document Document)
|
||
{
|
||
FilteredElementCollector col = new(Document, Document.ActiveView.Id);
|
||
ElementCategoryFilter categoryFilter1 = new(BuiltInCategory.OST_StructuralFraming);
|
||
col.WherePasses(categoryFilter1);
|
||
IEnumerable<Element> beams = col.GroupBy(g => g.Name).Select(s => s.FirstOrDefault());
|
||
|
||
foreach (FamilyInstance familyInstance in beams)
|
||
{
|
||
XYZ loc = (familyInstance.Location as LocationPoint).Point;
|
||
List<Face> faces = GetSideFacesByElement(familyInstance);
|
||
if (faces.Count == 0) //找不到实例的几何元素时，需从类型集合查找
|
||
{
|
||
Options options = new() { ComputeReferences = true };
|
||
faces = GetFacesByFamilyInstance(familyInstance, options);
|
||
for (int i = faces.Count - 1; i >= 0; i--)
|
||
{
|
||
PlanarFace pf = faces[i] as PlanarFace;
|
||
if (pf.FaceNormal.CrossProduct(XYZ.BasisZ).IsAlmostEqualTo(XYZ.Zero))
|
||
{
|
||
faces.Remove(faces[i]); //移除顶面底面
|
||
}
|
||
}
|
||
}
|
||
|
||
ReferenceArray referenceArray = new();
|
||
ReferenceArrayArray referenceArrayArray = new();
|
||
GetParallFacesReferenceArray(faces, faces.FirstOrDefault(), referenceArray, referenceArrayArray);
|
||
foreach (ReferenceArray array in referenceArrayArray)
|
||
{
|
||
PlanarFace face = familyInstance.GetGeometryObjectFromReference(array.get_Item(0)) as PlanarFace;
|
||
Line line = Line.CreateUnbound(loc, face.FaceNormal).CreateOffset(600 / 304.8, XYZ.BasisZ) as Line;
|
||
Document.Create.NewDimension(Document.ActiveView, line, array);
|
||
}
|
||
}
|
||
}
|
||
|
||
public void CreateColumnsDimension(Document Document, View view)
|
||
{
|
||
FilteredElementCollector col = new(Document, view.Id);
|
||
ElementCategoryFilter categoryFilter1 = new(BuiltInCategory.OST_StructuralColumns);
|
||
ElementCategoryFilter categoryFilter2 = new(BuiltInCategory.OST_Columns);
|
||
LogicalOrFilter andFilter = new(categoryFilter1, categoryFilter2);
|
||
col.WherePasses(andFilter);
|
||
IEnumerable<Element> columns = col.GroupBy(g => g.Name).Select(s => s.FirstOrDefault());
|
||
|
||
foreach (FamilyInstance familyInstance in columns)
|
||
{
|
||
XYZ loc = (familyInstance.Location as LocationPoint).Point;
|
||
List<Face> faces = GetSideFacesByElement(familyInstance);
|
||
if (faces.Count == 0) //找不到实例的几何元素时，需从类型集合查找
|
||
{
|
||
Options options = new() { ComputeReferences = true };
|
||
faces = GetFacesByFamilyInstance(familyInstance, options);
|
||
for (int i = faces.Count - 1; i >= 0; i--)
|
||
{
|
||
if (faces[i] is PlanarFace)
|
||
{
|
||
PlanarFace pf = faces[i] as PlanarFace;
|
||
if (pf.FaceNormal.CrossProduct(XYZ.BasisZ).IsAlmostEqualTo(XYZ.Zero))
|
||
{
|
||
faces.Remove(faces[i]); //移除顶面底面
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
ReferenceArray referenceArray = new();
|
||
ReferenceArrayArray referenceArrayArray = new();
|
||
GetParallFacesReferenceArray(faces, faces.FirstOrDefault(), referenceArray, referenceArrayArray);
|
||
foreach (ReferenceArray array in referenceArrayArray)
|
||
{
|
||
if (array.Size == 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
PlanarFace face = familyInstance.GetGeometryObjectFromReference(array.get_Item(0)) as PlanarFace;
|
||
Line line = Line.CreateUnbound(loc, face.FaceNormal).CreateOffset(600 / 304.8, XYZ.BasisZ) as Line;
|
||
Document.Create.NewDimension(Document.ActiveView, line, array);
|
||
}
|
||
}
|
||
}
|
||
|
||
private void CreateDimension(Document Document, View view, List<ModelCurve> mcurves)
|
||
{
|
||
List<Curve> lines = mcurves.Where(c => c is ModelLine).Select(mc => mc.GeometryCurve).ToList();
|
||
|
||
List<List<Curve>> groups = new();
|
||
GetParallLineGroups(lines, groups);
|
||
foreach (List<Curve> g in groups)
|
||
{
|
||
List<Line> gx = g.ConvertAll(x => x as Line);
|
||
if (!gx.Any())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
XYZ direction = gx.FirstOrDefault()?.Direction;
|
||
//IOrderedEnumerable<Line> orderedlist = null;
|
||
//if (direction.AngleTo(XYZ.BasisX) >= direction.AngleTo(XYZ.BasisY))
|
||
//{
|
||
// orderedlist = gx.OrderBy(l => l.Direction.X);
|
||
//}
|
||
//else
|
||
//{
|
||
// orderedlist = gx.OrderBy(l => l.Direction.Y);
|
||
//}
|
||
|
||
if (g.Count <= 1)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
Line line =
|
||
Line.CreateUnbound(g.FirstOrDefault()?.GetEndPoint(0), direction.CrossProduct(XYZ.BasisZ))
|
||
.CreateOffset(1500 / 304.8, XYZ.BasisZ) as Line;
|
||
Line line1 =
|
||
Line.CreateUnbound(g.FirstOrDefault()?.GetEndPoint(1), direction.CrossProduct(XYZ.BasisZ))
|
||
.CreateOffset(1500 / 304.8, XYZ.BasisZ) as Line;
|
||
ReferenceArray arrayAll = new();
|
||
foreach (Curve l in g)
|
||
{
|
||
arrayAll.Append(l.Reference);
|
||
}
|
||
|
||
Dimension dimension1 = Document.Create.NewDimension(view, line, arrayAll);
|
||
Dimension dimension2 = Document.Create.NewDimension(view, line1, arrayAll);
|
||
Document.Regenerate();
|
||
Line line3 =
|
||
Line.CreateUnbound(g.FirstOrDefault()?.GetEndPoint(0), direction.CrossProduct(XYZ.BasisZ))
|
||
.CreateOffset(1000 / 304.8, XYZ.BasisZ) as Line;
|
||
Line line4 =
|
||
Line.CreateUnbound(g.FirstOrDefault()?.GetEndPoint(1), direction.CrossProduct(XYZ.BasisZ))
|
||
.CreateOffset(1000 / 304.8, XYZ.BasisZ) as Line;
|
||
|
||
ReferenceArray array = new();
|
||
array.Append(dimension1.References.get_Item(0));
|
||
array.Append(dimension1.References.get_Item(arrayAll.Size - 1));
|
||
Document.Create.NewDimension(view, line3, array);
|
||
Document.Create.NewDimension(view, line4, array);
|
||
Document.Regenerate();
|
||
}
|
||
}
|
||
|
||
private void CreateWallDimension(Document Document, View view)
|
||
{
|
||
FilteredElementCollector wallCol = new FilteredElementCollector(Document, view.Id).OfClass(typeof(Wall));
|
||
|
||
foreach (Wall wall in wallCol)
|
||
{
|
||
if (wall.WallType.Kind != WallKind.Basic)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
LocationCurve loc = wall.Location as LocationCurve;
|
||
ReferenceArray wallThickReferenceArray = new();
|
||
ReferenceArray wallLengthRefernceArray = new();
|
||
List<Face> faces = GetSideFacesByElement(wall);
|
||
|
||
foreach (Face face in faces)
|
||
{
|
||
PlanarFace pf = face as PlanarFace;
|
||
if (pf == null || face.Reference == null || pf.OrientationMatchesSurfaceOrientation == false)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (pf.FaceNormal.CrossProduct(wall.Orientation).IsAlmostEqualTo(XYZ.Zero))
|
||
{
|
||
if (Document.GetElement(face.Reference).Id == wall.Id)
|
||
{
|
||
wallThickReferenceArray.Append(face.Reference);
|
||
}
|
||
}
|
||
else if (pf.FaceNormal.DotProduct(wall.Orientation) < 0.001)
|
||
{
|
||
wallLengthRefernceArray.Append(face.Reference);
|
||
}
|
||
}
|
||
|
||
try
|
||
{
|
||
int scale = Document.ActiveView.Scale;
|
||
Autodesk.Revit.DB.Transform tranform = Autodesk.Revit.DB.Transform.CreateTranslation(
|
||
wall.Orientation * scale * 15 / 304.8
|
||
);
|
||
Line wallcurve = (wall.Location as LocationCurve).Curve as Line;
|
||
Line lengthLine = wallcurve.CreateTransformed(tranform) as Line;
|
||
Dimension lengthdim = Document.Create.NewDimension(Document.ActiveView, lengthLine, wallLengthRefernceArray);
|
||
Document.Regenerate();
|
||
|
||
ReferenceArray finallengthreferenceArray = RemoveZeroSegements(wall, wallLengthRefernceArray, lengthdim);
|
||
Document.Delete(lengthdim.Id);
|
||
Document.Create.NewDimension(Document.ActiveView, lengthLine, finallengthreferenceArray);
|
||
|
||
Line thickLine = Line.CreateUnbound(wallcurve.Evaluate(0.2, true), wall.Orientation);
|
||
Dimension thickdim = Document.Create.NewDimension(Document.ActiveView, thickLine, wallThickReferenceArray);
|
||
|
||
if (lengthdim.Segments.Size > 2)
|
||
{
|
||
ReferenceArray referenceArray = new();
|
||
Reference refer1 = lengthdim.References.get_Item(0);
|
||
Reference refer2 = lengthdim.References.get_Item(lengthdim.References.Size - 1);
|
||
referenceArray.Append(refer1);
|
||
referenceArray.Append(refer2);
|
||
Autodesk.Revit.DB.Transform tranform1 = Autodesk.Revit.DB.Transform.CreateTranslation(
|
||
wall.Orientation * scale * 25 / 304.8
|
||
);
|
||
Line lengthLine1 = wallcurve.CreateTransformed(tranform1) as Line;
|
||
|
||
Document.Create.NewDimension(Document.ActiveView, lengthLine1, referenceArray);
|
||
}
|
||
}
|
||
catch (Exception) { }
|
||
}
|
||
}
|
||
|
||
public void GetParallFacesReferenceArray(
|
||
List<Face> faces,
|
||
Face firstFace,
|
||
ReferenceArray referenceArray,
|
||
ReferenceArrayArray referenceArrayArray
|
||
)
|
||
{
|
||
if (referenceArrayArray.Size == 0)
|
||
{
|
||
referenceArrayArray.Append(referenceArray);
|
||
}
|
||
|
||
for (int i = 0; i < faces.Count; i++)
|
||
{
|
||
if (faces[i] is not PlanarFace)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
PlanarFace tempFace = faces[i] as PlanarFace;
|
||
PlanarFace pf = firstFace as PlanarFace;
|
||
XYZ facenormal = pf.FaceNormal;
|
||
//把初始的第一个添加进集合
|
||
|
||
if (tempFace.FaceNormal.CrossProduct(facenormal).IsAlmostEqualTo(XYZ.Zero))
|
||
{
|
||
referenceArray.Append(tempFace.Reference);
|
||
faces.Remove(tempFace);
|
||
GetParallFacesReferenceArray(faces, tempFace, referenceArray, referenceArrayArray);
|
||
}
|
||
|
||
if (i == faces.Count() - 1)
|
||
{
|
||
referenceArray = new ReferenceArray();
|
||
GetParallFacesReferenceArray(faces, faces.FirstOrDefault(), referenceArray, referenceArrayArray);
|
||
if (!faces.Any())
|
||
{
|
||
referenceArrayArray.Append(referenceArray);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 递归找到所有平行线集合
|
||
/// </summary>
|
||
public static void GetParallLineGroups(List<Curve> lines, List<List<Curve>> groups)
|
||
{
|
||
Curve firstLine = lines.FirstOrDefault();
|
||
lines = lines.FindAll(curve => curve is Line);
|
||
List<Curve> group = new() { firstLine };
|
||
groups.Add(group);
|
||
Line line = firstLine as Line;
|
||
lines.Remove(firstLine);
|
||
|
||
for (int i = lines.Count - 1; i >= 0; i--)
|
||
{
|
||
if (lines[i] is not Line)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
Line tempLine = lines[i] as Line;
|
||
|
||
if (
|
||
tempLine.Direction.CrossProduct(line.Direction).IsAlmostEqualTo(XYZ.Zero)
|
||
&& Math.Abs(tempLine.Length - line.Length) < 0.00001
|
||
)
|
||
{
|
||
group.Add(tempLine);
|
||
lines.Remove(tempLine);
|
||
|
||
//GetParallFaces(faces, tempFace, ZoomRBGroup, groups);
|
||
}
|
||
}
|
||
|
||
if (lines.Count >= 1)
|
||
{
|
||
GetParallLineGroups(lines, groups);
|
||
}
|
||
}
|
||
|
||
private void TransientGrid(Document Document, Grid grid)
|
||
{
|
||
double radius = 1.5;
|
||
double size = 1.8;
|
||
XYZ startp = grid.Curve.GetEndPoint(0);
|
||
XYZ endp = grid.Curve.GetEndPoint(1);
|
||
XYZ direction = grid.Curve.ComputeDerivatives(0, true).BasisX.Normalize().Negate();
|
||
XYZ direction1 = grid.Curve.ComputeDerivatives(1, true).BasisX.Normalize();
|
||
XYZ loc = startp + (direction * radius);
|
||
XYZ loc1 = endp + (direction1 * radius);
|
||
|
||
IEnumerable<Curve> text = Text.FromStringOriginAndScale(grid.Name, loc, size);
|
||
IEnumerable<Curve> text1 = Text.FromStringOriginAndScale(grid.Name, loc1, size);
|
||
|
||
Arc circle = Arc.Create(loc, radius, 0, Math.PI * 2, XYZ.BasisX, XYZ.BasisY);
|
||
Arc circle1 = Arc.Create(loc1, radius, 0, Math.PI * 2, XYZ.BasisX, XYZ.BasisY);
|
||
List<GeometryObject> geoms = new() { grid.Curve, circle, circle1 };
|
||
geoms.AddRange(text);
|
||
geoms.AddRange(text1);
|
||
MethodInfo method = GenerateTransientDisplayMethod();
|
||
object[] argsM = new object[4];
|
||
argsM[0] = Document;
|
||
argsM[1] = ElementId.InvalidElementId;
|
||
argsM[2] = geoms;
|
||
argsM[3] = ElementId.InvalidElementId;
|
||
ElementId transientElementId = (ElementId)method.Invoke(null, argsM);
|
||
MessageBox.Show(transientElementId.IntegerValue.ToString(), "元素ID");
|
||
//doc.Delete(transientElementId);
|
||
}
|
||
}
|
||
|
||
public class TransientElementMaker : ITransientElementMaker
|
||
{
|
||
private readonly Document _document;
|
||
|
||
public List<GeometryObject> GeometryObjects { get; set; }
|
||
|
||
public TransientElementMaker(Document document)
|
||
{
|
||
_document = document;
|
||
}
|
||
|
||
public void Execute()
|
||
{
|
||
if (GeometryObjects != null)
|
||
{
|
||
DirectShape ds = DirectShape.CreateElement(_document, new ElementId(BuiltInCategory.OST_GenericModel));
|
||
//CreateUtils.CreateCube(), CreateUtils.CreateSphere()为创建一个立方体与球体Solid,文略
|
||
//ds.AppendShape(GeometryObjects);
|
||
ds.AppendShape(new List<GeometryObject> { CreateCube() });
|
||
}
|
||
}
|
||
|
||
public Solid CreateCube()
|
||
{
|
||
CurveLoop cubeBaseLines = new();
|
||
cubeBaseLines.Append(Line.CreateBound(new XYZ(0, 0, 0), new XYZ(100, 0, 0)));
|
||
cubeBaseLines.Append(Line.CreateBound(new XYZ(100, 0, 0), new XYZ(100, 100, 0)));
|
||
cubeBaseLines.Append(Line.CreateBound(new XYZ(100, 100, 0), new XYZ(0, 100, 0)));
|
||
cubeBaseLines.Append(Line.CreateBound(new XYZ(0, 100, 0), new XYZ(0, 0, 0)));
|
||
Solid solidCube = GeometryCreationUtilities.CreateExtrusionGeometry(new List<CurveLoop> { cubeBaseLines }, XYZ.BasisZ, 100);
|
||
|
||
return solidCube;
|
||
}
|
||
}
|
||
|
||
public static class Text
|
||
{
|
||
public static IEnumerable<Curve> FromStringOriginAndScale(string text, XYZ origin, double scale)
|
||
{
|
||
//http://msdn.microsoft.com/en-us/library/ms745816(v=vs.110).aspx
|
||
|
||
List<Curve> crvs = new();
|
||
|
||
FontFamily font = new("Arial");
|
||
FontStyle fontStyle = FontStyles.Normal;
|
||
FontWeight fontWeight = FontWeights.Medium;
|
||
|
||
//if (Bold == true) fontWeight = FontWeights.Bold;
|
||
//if (Italic == true) fontStyle = FontStyles.Italic;
|
||
|
||
// Create the formatted text based on the properties set.
|
||
#if REVIT2019||REVIT2020
|
||
System.Windows.Media.FormattedText formattedText =
|
||
new(
|
||
text,
|
||
CultureInfo.GetCultureInfo("en-us"),
|
||
FlowDirection.LeftToRight,
|
||
new Typeface(font, fontStyle, fontWeight, FontStretches.Normal),
|
||
1,
|
||
Brushes.Black,
|
||
1 // This brush does not matter since we use the geometry of the text.
|
||
);
|
||
#elif REVIT2018
|
||
var formattedText = new System.Windows.Media.FormattedText(
|
||
text,
|
||
CultureInfo.GetCultureInfo("en-us"),
|
||
FlowDirection.LeftToRight,
|
||
new Typeface(font, fontStyle, fontWeight, FontStretches.Normal),
|
||
1,
|
||
Brushes.Black // This brush does not matter since we use the geometry of the text.
|
||
,
|
||
1.25
|
||
);
|
||
#endif
|
||
// Build the geometry object that represents the text.
|
||
Geometry textGeometry = formattedText.BuildGeometry(new System.Windows.Point(0, 0));
|
||
foreach (PathFigure figure in textGeometry.GetFlattenedPathGeometry().Figures)
|
||
{
|
||
System.Windows.Point init = figure.StartPoint;
|
||
System.Windows.Point a = figure.StartPoint;
|
||
System.Windows.Point b;
|
||
foreach (PathSegment segment in figure.GetFlattenedPathFigure().Segments)
|
||
{
|
||
if (segment is System.Windows.Media.LineSegment lineSeg)
|
||
{
|
||
b = lineSeg.Point;
|
||
Line crv = LineBetweenPoints(origin, scale, a, b);
|
||
a = b;
|
||
crvs.Add(crv);
|
||
}
|
||
|
||
if (segment is PolyLineSegment plineSeg)
|
||
{
|
||
foreach (System.Windows.Point segPt in plineSeg.Points)
|
||
{
|
||
Line crv = LineBetweenPoints(origin, scale, a, segPt);
|
||
a = segPt;
|
||
crvs.Add(crv);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return crvs;
|
||
}
|
||
|
||
private static Line LineBetweenPoints(XYZ origin, double scale, System.Windows.Point a, System.Windows.Point b)
|
||
{
|
||
XYZ pt1 = new((a.X * scale) + origin.X, ((-a.Y + 1) * scale) + origin.Y, origin.Z);
|
||
XYZ pt2 = new((b.X * scale) + origin.X, ((-b.Y + 1) * scale) + origin.Y, origin.Z);
|
||
Line crv = Line.CreateBound(pt1, pt2);
|
||
return crv;
|
||
}
|
||
}
|
||
}
|