/// <summary>
/// Create a Revit Grid Element in a Project along a Line.
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
public static Grid ByLine(Autodesk.DesignScript.Geometry.Line line)
{
if (Document.IsFamilyDocument)
{
throw new Exception("A Grid Element can only be created in a Revit Project");
}
if (line == null)
{
throw new ArgumentNullException("line");
}
return new Grid( (Autodesk.Revit.DB.Line) line.ToRevitType());
}
/// <summary>
/// Create a Revit Grid Element in a project along an Arc
/// </summary>
/// <param name="arc"></param>
/// <returns></returns>
public static Grid ByArc(Autodesk.DesignScript.Geometry.Arc arc)
{
if (Document.IsFamilyDocument)
{
throw new Exception("A Grid Element can only be created in a Revit Project");
}
if (arc == null)
{
throw new ArgumentNullException("arc");
}
return new Grid( (Autodesk.Revit.DB.Arc) arc.ToRevitType() );
}
/// <summary>
/// Create a brace.
/// </summary>
/// <param name="curve">The cruve which defines the center line of the brace.</param>
/// <param name="level">The level with which you'd like the brace to be associated.</param>
/// <param name="structuralFramingType">The structural framing type representing the brace.</param>
/// <returns></returns>
public static StructuralFraming BraceByCurve(Autodesk.DesignScript.Geometry.Curve curve, Revit.Elements.Level level, Revit.Elements.FamilySymbol structuralFramingType)
{
if (curve == null)
{
throw new System.ArgumentNullException("curve");
}
if (level == null)
{
throw new System.ArgumentNullException("level");
}
if (structuralFramingType == null)
{
throw new System.ArgumentNullException("structuralFramingType");
}
return new StructuralFraming(curve.ToRevitType(), level.InternalLevel, Autodesk.Revit.DB.Structure.StructuralType.Brace, structuralFramingType.InternalFamilySymbol);
}
/// <summary>
/// Create a column.
/// </summary>
/// <param name="curve">The curve which defines the center line of the column.</param>
/// <param name="level">The level with which you'd like the column to be associated.</param>
/// <param name="structuralColumnType">The structural column type representing the column.</param>
/// <returns></returns>
public static StructuralFraming ColumnByCurve(
Autodesk.DesignScript.Geometry.Curve curve, Revit.Elements.Level level, Revit.Elements.FamilySymbol structuralColumnType)
{
if (curve == null)
{
throw new System.ArgumentNullException("curve");
}
if (level == null)
{
throw new System.ArgumentNullException("level");
}
if (structuralColumnType == null)
{
throw new System.ArgumentNullException("structuralColumnType");
}
var start = curve.PointAtParameter(0);
var end = curve.PointAtParameter(1);
// Revit will throw an exception if you attempt to create a column whose
// base is above its top.
if (end.Z <= start.Z)
{
throw new Exception("The end of the curve for creating a column should be above the start of the curve.");
}
return new StructuralFraming(curve.ToRevitType(), level.InternalLevel, Autodesk.Revit.DB.Structure.StructuralType.Column, structuralColumnType.InternalFamilySymbol);
}
/// <summary>
/// Create a Revit Perspective View from an Eye position and target position and Bounding Box
/// </summary>
/// <param name="eyePoint">Eye point in meters</param>
/// <param name="target">Target of view in meters</param>
/// <param name="boundingBox">Bounding box represented in meters</param>
/// <param name="name"></param>
/// <param name="isolateElement"></param>
/// <returns></returns>
public static PerspectiveView ByEyePointTargetAndBoundingBox(Autodesk.DesignScript.Geometry.Point eyePoint, Autodesk.DesignScript.Geometry.Point target, Autodesk.DesignScript.Geometry.BoundingBox boundingBox, string name, bool isolateElement)
{
if (boundingBox == null)
{
throw new ArgumentNullException("boundingBox");
}
if (eyePoint == null)
{
throw new ArgumentNullException("eyePoint");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
return new PerspectiveView(eyePoint.ToXyz(), target.ToXyz(), boundingBox.ToRevitType(), name, isolateElement);
}
/// <summary>
/// Create a Revit Structural Member - a special FamilyInstance
/// </summary>
/// <param name="curve">The curve path for the structural member</param>
/// <param name="upVector">The up vector for the element - this is required to determine the orientation of the element</param>
/// <param name="level">The level on which the member should appear</param>
/// <param name="structuralType">The type of the structural element - a beam, column, etc</param>
/// <param name="structuralFramingType">The structural framing type representing the structural type</param>
/// <returns></returns>
public static StructuralFraming ByCurveLevelUpVectorAndType(Autodesk.DesignScript.Geometry.Curve curve, Level level,
Autodesk.DesignScript.Geometry.Vector upVector, StructuralType structuralType, FamilySymbol structuralFramingType)
{
if (curve == null)
{
throw new System.ArgumentNullException("curve");
}
if (level == null)
{
throw new System.ArgumentNullException("level");
}
if (upVector == null)
{
throw new System.ArgumentNullException("upVector");
}
if (structuralFramingType == null)
{
throw new System.ArgumentNullException("structuralFramingType");
}
return new StructuralFraming(curve.ToRevitType(), upVector.ToXyz(), level.InternalLevel,
structuralType.ToRevitType(), structuralFramingType.InternalFamilySymbol);
}
/// <summary>
/// Create Rebar by Curves
/// </summary>
/// <param name="curves">Input Curves</param>
/// <param name="hostElementId">Host Element Id</param>
/// <param name="rebarStyle">Rebar Style</param>
/// <param name="rebarBarType">Bar Type</param>
/// <param name="startHookOrientation">Hokk orientation at the start</param>
/// <param name="endHookOrientation">Hook orientation at the end</param>
/// <param name="startHookType">Hook type at the start</param>
/// <param name="startHookType">Hook type at the start</param>
/// <param name="endHookType">Hook type at the end</param>
/// <param name="vector">Normal Vectors</param>
/// <returns></returns>
public static Rebar ByCurve(
Autodesk.DesignScript.Geometry.Curve curve,
int hostElementId,
string rebarStyle,
Revit.Elements.Element rebarBarType,
string startHookOrientation,
string endHookOrientation,
Revit.Elements.Element startHookType,
Revit.Elements.Element endHookType,
Autodesk.DesignScript.Geometry.Vector vector
)
{
if (curve == null) throw new ArgumentNullException("Input Curve missing");
if (hostElementId == null) throw new ArgumentNullException("Host ElementId missing");
if (rebarStyle == null) throw new ArgumentNullException("Rebar Style missing");
if (rebarBarType == null) throw new ArgumentNullException("Rebar Bar Type missing");
if (startHookOrientation == null) throw new ArgumentNullException("Start Hook Orientation missing");
if (endHookOrientation == null) throw new ArgumentNullException("End Hook Orientation missing");
//if (startHookType == null) throw new ArgumentNullException("Start Hook Type missing");
//if (endHookType == null) throw new ArgumentNullException("End Hook Type missing");
if (vector == null) throw new ArgumentNullException("Normal Vector missing");
ElementId elementId = new ElementId(hostElementId);
if (elementId == ElementId.InvalidElementId) throw new ArgumentNullException("Host ElementId error");
Autodesk.Revit.DB.Element host = DocumentManager.Instance.CurrentDBDocument.GetElement(elementId);
Autodesk.Revit.DB.Structure.RebarStyle barStyle = Autodesk.Revit.DB.Structure.RebarStyle.StirrupTie;
Enum.TryParse<Autodesk.Revit.DB.Structure.RebarStyle>(rebarStyle, out barStyle);
Autodesk.Revit.DB.Structure.RebarHookOrientation startOrientation = Autodesk.Revit.DB.Structure.RebarHookOrientation.Left;
Enum.TryParse<Autodesk.Revit.DB.Structure.RebarHookOrientation>(startHookOrientation, out startOrientation);
Autodesk.Revit.DB.Structure.RebarHookOrientation endOrientation = Autodesk.Revit.DB.Structure.RebarHookOrientation.Left;
Enum.TryParse<Autodesk.Revit.DB.Structure.RebarHookOrientation>(endHookOrientation, out endOrientation);
Autodesk.Revit.DB.Structure.RebarHookType startHookT = (startHookType == null) ? null : (Autodesk.Revit.DB.Structure.RebarHookType)startHookType.InternalElement;
Autodesk.Revit.DB.Structure.RebarHookType endHookT = (endHookType == null) ? null : (Autodesk.Revit.DB.Structure.RebarHookType)endHookType.InternalElement;
return new Rebar(curve.Approximate(), (Autodesk.Revit.DB.Structure.RebarBarType)rebarBarType.InternalElement, barStyle, host, startHookT, endHookT
, startOrientation, endOrientation, vector.ToRevitType(), true, true);
}
// <summary>
/// Construct a Revit ModelCurve element from a Curve
/// </summary>
/// <param name="curve"></param>
/// <returns></returns>
public static ModelCurve ReferenceCurveByCurve(Autodesk.DesignScript.Geometry.Curve curve)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
return new ModelCurve(curve.ToRevitType(), true);
}
/// <summary>
/// Create a Revit Wall from a guiding Curve, height, Level, and WallType
/// </summary>
/// <param name="curve"></param>
/// <param name="height"></param>
/// <param name="level"></param>
/// <param name="wallType"></param>
/// <returns></returns>
public static Wall ByCurveAndHeight(Autodesk.DesignScript.Geometry.Curve curve, double height, Level level, WallType wallType)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
if (level == null)
{
throw new ArgumentNullException("level");
}
if (wallType == null)
{
throw new ArgumentNullException("wallType");
}
height = height*UnitConverter.DynamoToHostFactor;
if (height < 1e-6 || height > 30000)
{
throw new ArgumentException(
"The height must be greater than 0 and less that 30000 ft. You provided a height of "
+ height + " ft.");
}
return new Wall(curve.ToRevitType(), wallType.InternalWallType, level.InternalLevel, height, 0.0, false, false);
}
/// <summary>
/// Create an element based Tag
/// </summary>
/// <param name="view">View to Tag</param>
/// <param name="element">Element to tag</param>
/// <param name="horizontal">Horizontal alignment</param>
/// <param name="addLeader">Add a leader</param>
/// <param name="offset">Offset Vector or Tag Location</param>
/// <param name="isOffset">Specifies if the point is being used as an offset vector or if it specifies the tags location</param>
/// <param name="horizontalAlignment">Horizontal Alignment</param>
/// <param name="verticalAlignment">Vertical Alignment</param>
/// <returns></returns>
public static Tag ByElement(Revit.Elements.Views.View view, Element element, bool horizontal, bool addLeader, Autodesk.DesignScript.Geometry.Point offset = null, bool isOffset = true, string horizontalAlignment = "Center", string verticalAlignment = "Middle")
{
if (offset == null) offset = Autodesk.DesignScript.Geometry.Point.ByCoordinates(0, 0, 0);
Autodesk.Revit.DB.HorizontalAlignmentStyle alignHorizontal = Autodesk.Revit.DB.HorizontalAlignmentStyle.Center;
Enum.TryParse<Autodesk.Revit.DB.HorizontalAlignmentStyle>(horizontalAlignment, out alignHorizontal);
Autodesk.Revit.DB.VerticalAlignmentStyle alignVertical = Autodesk.Revit.DB.VerticalAlignmentStyle.Middle;
Enum.TryParse<Autodesk.Revit.DB.VerticalAlignmentStyle>(verticalAlignment, out alignVertical);
//Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
Autodesk.Revit.DB.View revitView = (Autodesk.Revit.DB.View)view.InternalElement;
Autodesk.Revit.DB.XYZ point = offset.ToRevitType(true);
Autodesk.Revit.DB.TagMode tagMode = TagMode.TM_ADDBY_CATEGORY;
Autodesk.Revit.DB.TagOrientation orientation = (horizontal) ? TagOrientation.Horizontal : TagOrientation.Vertical;
if (revitView.ViewType != ViewType.FloorPlan &&
revitView.ViewType != ViewType.EngineeringPlan &&
revitView.ViewType != ViewType.Detail &&
revitView.ViewType != ViewType.Section &&
revitView.ViewType != ViewType.Elevation &&
revitView.ViewType != ViewType.CeilingPlan)
throw new ArgumentException("Cannot place a Tag on active View");
if (isOffset)
{
BoundingBoxXYZ box = element.InternalElement.get_BoundingBox(revitView);
if (box == null) box = element.InternalElement.get_BoundingBox(null);
if (box != null)
{
double Y, X = 0;
switch (alignVertical)
{
case VerticalAlignmentStyle.Bottom: Y = box.Min.Y; break;
case VerticalAlignmentStyle.Top: Y = box.Max.Y; break;
default: Y = box.Min.Y + ((box.Max.Y - box.Min.Y) / 2); break;
}
switch (alignHorizontal)
{
case HorizontalAlignmentStyle.Left: X = box.Min.X; break;
case HorizontalAlignmentStyle.Right: X = box.Max.X; break;
default: X = box.Min.X + ((box.Max.X - box.Min.X) / 2); break;
}
point = new XYZ(X + point.X, Y + point.Y, 0 + point.Z);
}
else
{
if (element.InternalElement.Location != null)
{
if (element.InternalElement.Location.GetType() == typeof(LocationCurve))
{
LocationCurve lc = (LocationCurve)element.InternalElement.Location;
XYZ midpoint = lc.Curve.Evaluate(0.5,true);
point = new XYZ(midpoint.X + point.X, midpoint.Y + point.Y, 0 + point.Z);
}
else if (element.InternalElement.Location.GetType() == typeof(LocationPoint))
{
LocationPoint lp = (LocationPoint)element.InternalElement.Location;
point = new XYZ(lp.Point.X + point.X, lp.Point.Y + point.Y, 0 + point.Z);
}
else
throw new ArgumentNullException("Cannot determine location");
}
else
throw new ArgumentNullException("Cannot determine location");
}
}
return new Tag(revitView, element.InternalElement, orientation, tagMode, addLeader, point);
}
/// <summary>
/// Create a Revit ViewSection by a bounding box
/// </summary>
/// <param name="box"></param>
/// <returns></returns>
public static SectionView ByBoundingBox(Autodesk.DesignScript.Geometry.BoundingBox box)
{
if (box == null)
{
throw new ArgumentNullException("box");
}
return new SectionView(box.ToRevitType());
}
public Dictionary<string, object> Intersect(Autodesk.DesignScript.Geometry.Curve curve)
{
if (curve == null)
{
throw new System.ArgumentNullException("curve");
}
var revitFace = this.InternalFace;
Autodesk.Revit.DB.IntersectionResultArray xsects = null;
var result = revitFace.Intersect(curve.ToRevitType(), out xsects);
var pts = new List<Autodesk.DesignScript.Geometry.Point>();
var uvs = new List<Autodesk.DesignScript.Geometry.UV>();
var parms = new List<double>();
var edges = new List<Edge>();
var edgeParms = new List<double>();
if (xsects != null)
{
foreach (IntersectionResult ir in xsects)
{
try
{
edgeParms.Add(ir.EdgeParameter);
}
catch
{
edgeParms.Add(0);
}
edges.Add(ir.EdgeObject != null ? Edge.FromExisting(ir.EdgeObject) : null);
parms.Add(ir.Parameter);
uvs.Add(Autodesk.DesignScript.Geometry.UV.ByCoordinates(ir.UVPoint.U, ir.UVPoint.V));
pts.Add(ir.XYZPoint.ToPoint());
}
}
return new Dictionary<string, object>()
{
{"point", pts.ToArray() },
{"uv", uvs.ToArray() },
{"parm", parms.ToArray() },
{"edge", edges.ToArray() },
{"edgeParm", edgeParms.ToArray() }
};
}
/// <summary>
/// Create geometry by blending profiles along a path.
/// </summary>
/// <param name="profiles"></param>
/// <param name="spine"></param>
/// <returns></returns>
public static Solid BySweptBlend(List<PolyCurve> profiles, Autodesk.DesignScript.Geometry.Curve spine, List<double> attachmentParameters)
{
if (profiles == null)
{
throw new ArgumentException("profiles");
}
if (profiles.Count < 1)
{
throw new Exception("You must have more than one profile to create a swept blend.");
}
if (profiles.Count != attachmentParameters.Count)
{
throw new Exception("You must have the same number of profiles as attachment parameters.");
}
var loops = profiles.Select(x => x.ToRevitType() ).ToList();
return new Solid(loops, spine.ToRevitType(), attachmentParameters);
}
/// <summary>
/// Create geometry by revolving a closed curve around an axis.
/// </summary>
/// <param name="profile">The profile to revolve.</param>
/// <param name="coordinateSystem">The coordinate system whose Z axis will be the axis of revolution.</param>
/// <param name="startAngle">The start angle in radians.</param>
/// <param name="endAngle">The end angle in radians.</param>
/// <returns></returns>
public static Solid ByRevolve(Autodesk.DesignScript.Geometry.PolyCurve profile, CoordinateSystem coordinateSystem, double startAngle, double endAngle )
{
if (profile == null)
{
throw new ArgumentException("profile");
}
if (coordinateSystem == null)
{
throw new ArgumentException("coordinate system");
}
var crvs = profile.ToRevitType();
return new Solid( crvs, coordinateSystem.ToTransform(), startAngle, endAngle);
}
private static Autodesk.Revit.DB.Curve ExtractLegalRevitCurve(Autodesk.DesignScript.Geometry.Curve curve)
{
// PB: PolyCurves may have discontinuities that prevent them from being turned into legal Revit ModelCurves.
// Moreover, a single ModelCurve may not be a composite or multiple curves.
// One could add a static method to ModelCurve that is an overload of ByCurve - ModelCurve[] ByCurve(PolyCurve).
// But, this adds an unnecessary high level of complexity to the Element rebinding code. Hence, we will go the
// more straightforward route of just providing an informative error message to the user.
if (curve is PolyCurve)
{
throw new Exception(
"Revit does not support turning PolyCurves into ModelCurves. "
+ "Try exploding your PolyCurve into multiple Curves.");
}
return curve.ToRevitType();
}
