public static List <Revit.Elements.Element> FindAllOfCategoryInFile(string SourceFilename, Revit.Elements.Category DynCat)
{
Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
Autodesk.Revit.UI.UIApplication uiapp = DocumentManager.Instance.CurrentUIApplication;
//TransactionManager.Instance.EnsureInTransaction(doc);
Document WallDoc = uiapp.Application.OpenDocumentFile(SourceFilename);
Autodesk.Revit.DB.Category FoundCat = GetRevitCategory(DynCat);
BuiltInCategory BIcat = (BuiltInCategory)DynCat.Id;
var Elements = new FilteredElementCollector(WallDoc)
.OfCategory(BIcat);
List <Revit.Elements.Element> AllElements = new List <Revit.Elements.Element>();
foreach (Autodesk.Revit.DB.Element TempEle in Elements)
{
Revit.Elements.Element WrappedEle = TempEle.ToDSType(false);
AllElements.Add(WrappedEle);
}
return(AllElements);
}
public static void TransferWallTypeToCurrentDoc(string SourceFilename, Revit.Elements.Element WallElementFromSource)
{
Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
Autodesk.Revit.UI.UIApplication uiapp = DocumentManager.Instance.CurrentUIApplication;
//TransactionManager.Instance.EnsureInTransaction(doc);
//Document WallDoc = uiapp.Application.OpenDocumentFile(SourceFilename);
Autodesk.Revit.DB.Element RevEle = ((Revit.Elements.Element)WallElementFromSource).InternalElement;
Document WallDoc = RevEle.Document;
List <ElementId> SourceElements = new List <ElementId>();
SourceElements.Add(RevEle.Id);
//SourceElements.Add(RevEle.GetTypeId());
TransactionManager.Instance.EnsureInTransaction(doc);
CopyPasteOptions cpOpt = new CopyPasteOptions();
try
{
ElementTransformUtils.CopyElements(WallDoc, SourceElements, doc, Transform.Identity, cpOpt);
}
catch (Exception ex)
{
throw;
}
//Close the transaction
TransactionManager.Instance.TransactionTaskDone();
}
/// <summary>
/// Convert a Revit Area into a SpaceBoundary element. This currently only
/// stores the perimeter polygon, and no geometric representation, so you will
/// not see it in 3D views in Hypar.
/// </summary>
/// <param name="revitArea">The area that is meant to be converted to a Hypar SpaceBoundary.</param>
/// <param name="areaPlan">Provide the view where the area is visible to speed up computation.</param>
/// <returns name="SpaceBoundary">The Hypar space boundary elements.</returns>
public static Elements.SpaceBoundary[] FromArea(DynamoRevit.Element revitArea, [DefaultArgument("HyparDynamo.Hypar.SpaceBoundary.GetNull()")] DynamoRevit.Views.AreaPlanView areaPlan = null)
{
var areaElement = (ADSK.Area)revitArea.InternalElement;
var doc = DocumentManager.Instance.CurrentDBDocument;
return(Create.SpaceBoundaryFromRevitArea(areaElement, doc, areaPlan == null ? null : (Autodesk.Revit.DB.View)areaPlan?.InternalElement));
}
public static Element Type(Element element)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
var e = element.InternalElement;
return(doc.GetElement(e.GetTypeId()).ToDSType(true));
}
public static List <Revit.Elements.Element> ExistsInPhase(List <Revit.Elements.Element> Element, Revit.Elements.Element Phase)
{
List <Revit.Elements.Element> vs = new List <Revit.Elements.Element>();
List <string> phaseStat = GetPhaseStatus(Element, Phase);
for (int i = 0; i < phaseStat.Count; i++)
{
string item = phaseStat[i];
Revit.Elements.Element element = Element[i];
switch (item)
{
case "New":
vs.Add(element);
break;
case "Existing":
vs.Add(element);
break;
case "Temporary":
vs.Add(element);
break;
default:
break;
}
}
return(vs);
}
public static dynElem ModifyElement(SerialElement serialElement,
[DefaultArgument("Synthetic.Revit.Document.Current()")] RevitDoc document)
{
dynElem elem = null;
Type type = serialElement.GetType();
if (type == typeof(SerialMaterial))
{
elem = SerialMaterial.ModifyMaterial((SerialMaterial)serialElement, document);
}
else if (type == typeof(SerialElementType))
{
elem = SerialElementType.ModifyElement((SerialElementType)serialElement, document);
}
else if (type == typeof(SerialHostObjType))
{
elem = SerialHostObjType.ModifyWallType((SerialHostObjType)serialElement, document);
}
else if (type == typeof(SerialView))
{
elem = SerialView.ModifyView((SerialView)serialElement, document);
}
else
{
elem = SerialElement.ModifyElement((SerialElement)serialElement, document);
}
return(elem);
}
/// <summary>
/// Overwrite an elements parameters with the parameter values from a source element.
/// </summary>
/// <param name="Element">Destination element</param>
/// <param name="SourceElement">Source element for the parameter values</param>
/// <returns name="Element">The destination element</returns>
public static DynaElem TransferParameters(DynaElem Element, DynaElem SourceElement)
{
string transactionName = "Transfer Parameter Between Elements";
Action <DynaElem, DynaElem> transfer = (sElem, dElem) =>
{
_transferParameters(sElem.InternalElement, dElem.InternalElement);
};
RevitDoc document = Element.InternalElement.Document;
if (document.IsModifiable)
{
TransactionManager.Instance.EnsureInTransaction(document);
transfer(SourceElement, Element);
TransactionManager.Instance.TransactionTaskDone();
}
else
{
using (Autodesk.Revit.DB.Transaction trans = new Autodesk.Revit.DB.Transaction(document))
{
trans.Start(transactionName);
transfer(SourceElement, Element);
trans.Commit();
}
}
return(Element);
}
/// <summary>
///
/// </summary>
/// <param name="fillPattern"></param>
/// <returns></returns>
public static string Orientation(Element fillPattern)
{
if (fillPattern == null)
{
throw new ArgumentException(nameof(fillPattern));
}
if (!(fillPattern.InternalElement is Autodesk.Revit.DB.FillPatternElement fpe))
{
throw new ArgumentException(nameof(fillPattern));
}
var fp = fpe.GetFillPattern();
switch (fp.HostOrientation)
{
case FillPatternHostOrientation.ToView:
return("Orient To View");
case FillPatternHostOrientation.AsText:
return("Keep Readable");
case FillPatternHostOrientation.ToHost:
return("Align with element");
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
///
/// </summary>
/// <param name="fillPattern"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Element SetName(Element fillPattern, string name)
{
if (fillPattern == null)
{
throw new ArgumentException(nameof(fillPattern));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
if (!(fillPattern.InternalElement is Autodesk.Revit.DB.FillPatternElement fpe))
{
throw new ArgumentException(nameof(fillPattern));
}
var doc = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(doc);
fpe.Name = name;
TransactionManager.Instance.TransactionTaskDone();
return(fpe.ToDSType(true));
}
public static Dictionary <string, object> SplitDuctByPoints(Revit.Elements.Element element, List <Autodesk.DesignScript.Geometry.Point> points)
{
string result = "";
Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
List <Revit.Elements.Element> splitDucts = new List <Revit.Elements.Element>();
ElementId eId = doc.GetElement(element.UniqueId.ToString()).Id;
Units units = doc.GetUnits();
FormatOptions fo = units.GetFormatOptions(UnitType.UT_Length);
try
{
foreach (Autodesk.DesignScript.Geometry.Point p in points)
{
double pX = UnitUtils.ConvertToInternalUnits(p.X, fo.DisplayUnits);
double pY = UnitUtils.ConvertToInternalUnits(p.Y, fo.DisplayUnits);
double pZ = UnitUtils.ConvertToInternalUnits(p.Z, fo.DisplayUnits);
XYZ ptBreak = new XYZ(pX, pY, pZ);
ElementId pieceOfPipe = MechanicalUtils.BreakCurve(doc, eId, ptBreak);
splitDucts.Add(doc.GetElement(pieceOfPipe).ToDSType(true));
}
}
catch (Exception ex)
{
result = ex.Message;
}
return(new Dictionary <string, object>
{
{ "elements", splitDucts },
{ "result", result }
});
}
/// <summary>
/// Create ceiling views by rooms, names and offset.
/// </summary>
/// <param name="Level">Level element</param>
/// <param name="Rooms"></param>
/// <param name="Names">List of names for new views</param>
/// <param name="Offset">Cropbox offset from room</param>
/// <returns name="CeilingView">Created Ceiling Views</returns>
public static List <Revit.Elements.Element> CeilingViewByRoom(Revit.Elements.Element Level, List <Revit.Elements.Room> Rooms, List <String> Names, double Offset = 500)
{
var CeilingView = new List <Revit.Elements.Element>();
var doc = DocumentManager.Instance.CurrentDBDocument;
var CViews = new FilteredElementCollector(doc).OfClass(typeof(View)).Cast <View>().Where(x => x.ViewType == ViewType.CeilingPlan).ToList();
var ceiling = from c in CViews where c.LookupParameter("Associated Level").AsString() == Level.Name.ToString() select c;
var view = ceiling.First();
TransactionManager.Instance.EnsureInTransaction(doc);
foreach (var elem in Rooms.Zip(Names, Tuple.Create))
{
var v = view.Duplicate(ViewDuplicateOption.WithDetailing);
BoundingBoxXYZ bbox = elem.Item1.InternalElement.get_BoundingBox(doc.ActiveView);
var newbbox = Utility.crop_box(bbox, Offset / 304.8);
var dupview = (Autodesk.Revit.DB.View)doc.GetElement(v);
dupview.Name = elem.Item2;
dupview.CropBox = newbbox;
dupview.CropBoxActive = true;
dupview.CropBoxVisible = true;
dupview.Scale = view.Scale;
CeilingView.Add(dupview.ToDSType(true));
}
TransactionManager.Instance.TransactionTaskDone();
return(CeilingView);
}
/// <summary>
/// Changes the workset of an element.
/// </summary>
/// <param name="element">Dynamo Elements.</param>
/// <param name="workset">A revit workset</param>
/// <returns name="element">The element that was changed. Returns null if the change was unsuccessfull.</returns>
public static dynamoElement SetElementWorkset(dynamoElement element, Workset workset)
{
//Get Revit Document object
revitDoc doc = DocumentManager.Instance.CurrentDBDocument;
Autodesk.Revit.DB.Element unwrapped = element.InternalElement;
WorksetId wId = unwrapped.WorksetId;
Autodesk.Revit.DB.Parameter wsParam = unwrapped.get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM);
if (wsParam == null)
{
return(null);
}
if (doc.IsModifiable)
{
wsParam.Set(workset.internalId.IntegerValue);
}
else
{
using (Autodesk.Revit.DB.Transaction tx = new Autodesk.Revit.DB.Transaction(doc))
{
tx.Start("Change Element's Workset");
wsParam.Set(workset.internalId.IntegerValue);
tx.Commit();
}
}
return(unwrapped.ToDSType(true));;
}
/// <summary>
/// Creates a new View Callout.
/// </summary>
/// <param name="view">View to create the Callout in.</param>
/// <param name="viewFamilyType">Type of Callout Family.</param>
/// <param name="extents">Extents of the Callout as Rectangle.</param>
/// <returns name="view">New Callout View.</returns>
/// <search>view, create, callout</search>
public static View CreateCallout(View view, Element viewFamilyType, Rectangle extents)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
var v = (Autodesk.Revit.DB.View)view.InternalElement;
var pt1 = extents.BoundingBox.MinPoint.ToXyz();
var pt2 = extents.BoundingBox.MaxPoint.ToXyz();
Autodesk.Revit.DB.View newView;
TransactionManager.Instance.EnsureInTransaction(doc);
switch (v.ViewType)
{
case Autodesk.Revit.DB.ViewType.FloorPlan:
case Autodesk.Revit.DB.ViewType.CeilingPlan:
case Autodesk.Revit.DB.ViewType.Elevation:
case Autodesk.Revit.DB.ViewType.Section:
case Autodesk.Revit.DB.ViewType.Detail:
newView = Autodesk.Revit.DB.ViewSection.CreateCallout(doc, v.Id,
viewFamilyType.InternalElement.Id, pt1, pt2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(view));
}
TransactionManager.Instance.TransactionTaskDone();
return((View)newView.ToDSType(true));
}
/// <summary>
/// Duplicates Element Type given a name doesn't exist. If it does it will return Element Type with that name.
/// </summary>
/// <param name="element">Element Type to duplicate.</param>
/// <param name="name">Name of Duplicated Type. Must be unique.</param>
/// <returns>New Element Type or Type with the given name if already exists.</returns>
public static Element Duplicate(Element element, string name)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
if (!(element.InternalElement is Autodesk.Revit.DB.ElementType e))
{
throw new Exception("Only Element Types can be duplicated.");
}
try
{
TransactionManager.Instance.EnsureInTransaction(doc);
var newType = e.Duplicate(name);
TransactionManager.Instance.TransactionTaskDone();
return(newType.ToDSType(true));
}
catch (Autodesk.Revit.Exceptions.ArgumentException)
{
var viewFam = DocumentManager.Instance.ElementsOfType <Autodesk.Revit.DB.ViewFamilyType>()
.FirstOrDefault(x => x.Name == name);
return(viewFam.ToDSType(true));
}
catch (Exception ex)
{
throw new Exception("Failed duplicating: " + ex.Message);
}
}
/// <summary>
/// Pick Faces in the current Revit Document. Don't forget to hit the Finished button in the options bar.
/// </summary>
/// <param name="message">A message to be displayed in the status bar.</param>
/// <param name="reset">Resets the node so one can pick new objects.</param>
/// <returns name="Faces">List of the selected faces.</returns>
public static List <DynElem> Faces(
[DefaultArgument("Select elements")] string message,
[DefaultArgument("true")] bool reset)
{
Autodesk.Revit.UI.UIApplication uiapp = DocumentManager.Instance.CurrentUIApplication;
RevitDoc doc = DocumentManager.Instance.CurrentDBDocument;
List <DynElem> elems = new List <DynElem>();
revitSelect.Selection selection = uiapp.ActiveUIDocument.Selection;
try
{
IList <Reference> references = selection.PickObjects(revitSelect.ObjectType.Face, message);
foreach (Reference r in references)
{
DynElem elem = doc.GetElement(r.ElementId).ToDSType(true);
elems.Add(elem);
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException e)
{
return(null);
}
return(elems);
}
/// <summary>
/// Creates a PipePlaceholder by two points.
/// </summary>
/// <param name="pipeType">Type of the pipe.</param>
/// <param name="systemType">Type of the system.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
/// <param name="level">The level.</param>
/// <returns></returns>
public static PipePlaceHolder ByPoints(Revit.Elements.Element pipeType, Revit.Elements.Element systemType, Autodesk.DesignScript.Geometry.Point start, Autodesk.DesignScript.Geometry.Point end, Revit.Elements.Level level)
{
Utils.Log(string.Format("PipePlaceHolder.ByPoints started...", ""));
var oType = pipeType.InternalElement as Autodesk.Revit.DB.Plumbing.PipeType;
var oSystemType = systemType.InternalElement as Autodesk.Revit.DB.Plumbing.PipingSystemType;
var totalTransform = RevitUtils.DocumentTotalTransform();
var nstart = start.Transform(totalTransform) as Autodesk.DesignScript.Geometry.Point;
var s = nstart.ToXyz();
var nend = end.Transform(totalTransform) as Autodesk.DesignScript.Geometry.Point;
var e = nend.ToXyz();
var l = level.InternalElement as Autodesk.Revit.DB.Level;
if (nstart != null)
{
nstart.Dispose();
}
if (nend != null)
{
nend.Dispose();
}
Utils.Log(string.Format("PipePlaceHolder.ByPoints completed.", ""));
return(new PipePlaceHolder(oType, oSystemType, s, e, l));
}
public static List <Revit.Elements.Element> GetElementsByCategory(Revit.Elements.Element Room, Revit.Elements.Category category)
{
DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
ElementId categoryId = new ElementId(category.Id);
DB.Category internalRevitCat = Autodesk.Revit.DB.Category.GetCategory(doc, categoryId);
FilteredElementCollector collector = new FilteredElementCollector(doc);
List <DB.Element> AllElementOfCategory = collector.OfCategoryId(internalRevitCat.Id).WhereElementIsNotElementType().ToElements().ToList();
DB.Element _room = (DB.Element)Room.InternalElement;
DB.Architecture.Room room = _room as DB.Architecture.Room;
List <Revit.Elements.Element> elems = new List <Revit.Elements.Element>();
List <Revit.Elements.Element> _elems = new List <Revit.Elements.Element>();
foreach (DB.Element element in AllElementOfCategory)
{
DB.FamilyInstance familyInstance = (DB.FamilyInstance)element;
LocationPoint familyInstanceLocationPoint = familyInstance.Location as LocationPoint;
XYZ point = familyInstanceLocationPoint.Point;
if (room.IsPointInRoom(point))
{
_elems.Add(element.ToDSType(true));
}
}
return(_elems);
}
/// <summary>
///
/// </summary>
/// <param name="room"></param>
/// <param name="boundaryLocation"></param>
/// <returns></returns>
public static double Height(Element room, string boundaryLocation = "Center")
{
if (room == null)
{
throw new ArgumentNullException(nameof(room));
}
var bLoc = (Autodesk.Revit.DB.SpatialElementBoundaryLocation)Enum.Parse(typeof(Autodesk.Revit.DB.SpatialElementBoundaryLocation), boundaryLocation);
var bOptions = new Autodesk.Revit.DB.SpatialElementBoundaryOptions
{
SpatialElementBoundaryLocation = bLoc
};
var doc = DocumentManager.Instance.CurrentDBDocument;
var rm = (Autodesk.Revit.DB.SpatialElement)room.InternalElement;
var calculator = new Autodesk.Revit.DB.SpatialElementGeometryCalculator(doc, bOptions);
var result = calculator.CalculateSpatialElementGeometry(rm);
var geo = result.GetGeometry();
var bb = geo.GetBoundingBox();
var height = bb.Max.Z - bb.Min.Z;
var fu = Autodesk.Revit.DB.UnitUtils.GetAllMeasurableSpecs()
.FirstOrDefault(x => x.TypeId.StartsWith("autodesk.spec.aec:length"));
var units = doc.GetUnits().GetFormatOptions(fu);
return(Autodesk.Revit.DB.UnitUtils.ConvertFromInternalUnits(height, units.GetUnitTypeId()));
}
public static List <Element> SubComponents(Element element)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
var e = element.InternalElement;
switch (e)
{
case Autodesk.Revit.DB.FamilyInstance fi:
return(fi.GetSubComponentIds().Select(x => doc.GetElement(x).ToDSType(true)).ToList());
case Autodesk.Revit.DB.Architecture.Stairs s:
var stairComponents = s.GetStairsLandings().Select(x => doc.GetElement(x).ToDSType(true)).ToList();
stairComponents.AddRange(s.GetStairsRuns().Select(x => doc.GetElement(x).ToDSType(true)));
stairComponents.AddRange(s.GetStairsSupports().Select(x => doc.GetElement(x).ToDSType(true)));
return(stairComponents);
case Autodesk.Revit.DB.Architecture.Railing r:
var railComponents = r.GetHandRails().Select(x => doc.GetElement(x).ToDSType(true)).ToList();
railComponents.Add(doc.GetElement(r.TopRail).ToDSType(true));
return(railComponents);
case Autodesk.Revit.DB.BeamSystem b:
return(b.GetBeamIds().Select(x => doc.GetElement(x).ToDSType(true)).ToList());
default:
return(new List <Element>());
}
}
public static Revit.Elements.Element GetbyName(string ViewName)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
FilteredElementCollector views = new FilteredElementCollector(doc).OfClass(typeof(View));
Revit.Elements.Element hold = views.Where(x => x.Name == ViewName).FirstOrDefault().ToDSType(true);
return(hold);
}
/// <summary>
/// Dynamo Unwrapper
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
internal static ElementId UnwrapElement(Revit.Elements.Element element)
{
Autodesk.Revit.DB.Element UnwrappedElement;
UnwrappedElement = element.InternalElement;
ElementId elementId = UnwrappedElement.Id;
return(elementId);
}
public static bool IsHiddenOnView(Revit.Elements.Element element, Revit.Elements.Views.View view)
{
// Unwrap elements
Autodesk.Revit.DB.Element elem = element.InternalElement;
Autodesk.Revit.DB.View inputView = (Autodesk.Revit.DB.View)view.InternalElement;
return(elem.IsHidden(inputView));
}
public static Revit.Elements.Element Unpin(this Revit.Elements.Element element)
{
TransactionManager.Instance.EnsureInTransaction(DocumentManager.Instance.CurrentDBDocument);
element.InternalElement.Pinned = false;
DocumentManager.Regenerate();
TransactionManager.Instance.TransactionTaskDone();
return(element);
}
public static dynElem CreateElementType(SerialElementType serialElementType, dynElem templateType)
{
RevitDoc document = templateType.InternalElement.Document;
dynElem elem = SerialElementType.CreateElementTypeByTemplate(serialElementType, (RevitElemType)templateType.InternalElement, document);
return(elem);
}
private static void GetExpectedWallHeight(Element wall, double value)
{
var name = "Unconnected Height";
var height = (double)(wall.GetParameterValueByName(name));
Assert.NotNull(height);
height.ShouldBeApproximately(value);
}
public static Revit.Elements.Element AssociatedLevel(Revit.Elements.Element View)
{
var doc = DocumentManager.Instance.CurrentDBDocument;
ElementId searcher = Spring.Elements.UnwrapElement(View);
View finalView = doc.GetElement(searcher) as View;
Revit.Elements.Element level = finalView.GenLevel.ToDSType(true);
return(level);
}
public static Revit.Elements.Element GetStartingView()
{
var doc = DocumentManager.Instance.CurrentDBDocument;
StartingViewSettings startingViewSettings = StartingViewSettings.GetStartingViewSettings(doc);
View finalView = doc.GetElement(startingViewSettings.ViewId) as View;
Revit.Elements.Element view = finalView.ToDSType(true);
return(view);
}
private static void AssertElementPinnedStatusIs(
Element element,
bool expectedValue)
{
bool pinStatus = element.IsPinned;
Assert.NotNull(pinStatus);
Assert.AreEqual(expectedValue, pinStatus);
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public static List <Connectors> Connectors(Element element)
{
if (!(element.InternalElement is Autodesk.Revit.DB.FamilyInstance e))
{
throw new ArgumentNullException(nameof(element));
}
return((from Autodesk.Revit.DB.Connector conn in e.MEPModel.ConnectorManager.Connectors
select new Connectors(conn)).ToList());
}
/// <summary>
/// Retrieves an element's workset.
/// </summary>
/// <param name="element">A Revit element.</param>
/// <returns name="workset">A Revit workset.</returns>
public static Workset GetElementWorkset(dynamoElement element)
{
//Get Revit Document object
revitDoc doc = DocumentManager.Instance.CurrentDBDocument;
WorksetId wid = element.InternalElement.WorksetId;
Workset workset = GetByWorksetId(wid);
return(workset);
}
/// <summary>
/// Create a group
/// from an Revit group
/// </summary>
/// <param name="element">The origin element</param>
/// <returns></returns>
public static Group FromElement(Element element)
{
if (element.InternalElement.GetType() == typeof(DB.Group))
{
return new Group(element.InternalElement as DB.Group);
}
else
{
throw new ArgumentException("The Element is not a Revit Group");
}
}
/// <summary>
///get all mullions of curtain wall, system or slope galzing roof
/// </summary>
/// <param name="hostingElement"></param>
public static Mullion[] ByElement(Element hostingElement)
{
CurtainGridSet thisSet = CurtainGrid.AllCurtainGrids(hostingElement.InternalElement);
var result = new List<Mullion>();
var enumGrid = thisSet.GetEnumerator();
for (; enumGrid.MoveNext();)
{
var grid = (Autodesk.Revit.DB.CurtainGrid) enumGrid.Current;
var ids = grid.GetMullionIds();
var idEnum = ids.GetEnumerator();
for (; idEnum.MoveNext();)
{
var idMullion = idEnum.Current;
var mullion = DocumentManager.Instance.CurrentDBDocument.GetElement(idMullion);
result.Add(Mullion.FromExisting(mullion as Autodesk.Revit.DB.Mullion, true));
}
}
return result.ToArray();
}
/// <summary>
/// Create a Room
/// from an existing Room
/// </summary>
/// <param name="element">The origin element</param>
/// <returns></returns>
public static CustomRoom FromElement(Element element)
{
if (element != null)
{
if (element.InternalElement.GetType() == typeof(DB.Architecture.Room))
{
return new CustomRoom(element.InternalElement as DB.Architecture.Room);
}
else
{
throw new ArgumentException("The Element is not a Room");
}
}
else
{
throw new ArgumentException("An error occured");
}
}
/// <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</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.Vector offset = null, string horizontalAlignment = "Center", string verticalAlignment = "Middle")
{
if (offset == null) offset = Autodesk.DesignScript.Geometry.Vector.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 = null;
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 (element.InternalElement.Location.GetType() == typeof(LocationPoint))
//{
// LocationPoint locationPoint = (LocationPoint)element.InternalElement.Location;
// point = locationPoint.Point;
//}
//else if (element.InternalElement.Location.GetType() == typeof(LocationCurve))
//{
// LocationCurve locationCurve = (LocationCurve)element.InternalElement.Location;
// point = locationCurve.Curve.GetEndPoint(0);
//}
//else
//{
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 + offset.X, Y + offset.Y, 0 + offset.Z);
}
else throw new ArgumentNullException("Cannot determine location");
//}
return new Tag(revitView, element.InternalElement, orientation, tagMode, addLeader, point);
}
/// <summary>
///get all panels of curtain wall, system or slope galzing roof
/// </summary>
/// <param name="hostingElement"></param>
public static CurtainPanel[] ByElement(Element hostingElement)
{
CurtainGridSet thisSet = CurtainGrid.AllCurtainGrids(hostingElement.InternalElement);
var result = new List<CurtainPanel>();
var enumGrid = thisSet.GetEnumerator();
for (; enumGrid.MoveNext(); )
{
var grid = (Autodesk.Revit.DB.CurtainGrid)enumGrid.Current;
var ids = grid.GetPanelIds();
var idEnum = ids.GetEnumerator();
for (; idEnum.MoveNext(); )
{
var idPanel = idEnum.Current;
var panel = DocumentManager.Instance.CurrentDBDocument.GetElement(idPanel);
result.Add(CurtainPanel.FromExisting(panel as Autodesk.Revit.DB.Panel, true));
}
}
return result.ToArray();
}
/// <summary>
/// Create an element based Tag
/// </summary>
/// <param name="element">Element to tag</param>
/// <param name="horizontal">Horizontal alignment</param>
/// <param name="addLeader">Add a leader</param>
/// <returns></returns>
public static Tag ByElement(Element element, bool horizontal, bool addLeader)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
Autodesk.Revit.DB.XYZ point = null;
Autodesk.Revit.DB.TagMode tagMode = TagMode.TM_ADDBY_CATEGORY;
Autodesk.Revit.DB.TagOrientation orientation = (horizontal)? TagOrientation.Horizontal : TagOrientation.Vertical;
if (document.ActiveView.ViewType != ViewType.FloorPlan &&
document.ActiveView.ViewType != ViewType.EngineeringPlan &&
document.ActiveView.ViewType != ViewType.Detail &&
document.ActiveView.ViewType != ViewType.Section &&
document.ActiveView.ViewType != ViewType.Elevation &&
document.ActiveView.ViewType != ViewType.CeilingPlan)
throw new ArgumentException("Cannot place a Tag on active View");
if (element.InternalElement.Location.GetType() == typeof(LocationPoint))
{
LocationPoint locationPoint = (LocationPoint)element.InternalElement.Location;
point = locationPoint.Point;
}
else if (element.InternalElement.Location.GetType() == typeof(LocationCurve))
{
LocationCurve locationCurve = (LocationCurve)element.InternalElement.Location;
point = locationCurve.Curve.GetEndPoint(0);
}
else
{
BoundingBoxXYZ box = element.InternalElement.get_BoundingBox(document.ActiveView);
if (box == null) box = element.InternalElement.get_BoundingBox(null);
if (box != null)
{
point = box.Min + ((box.Max - box.Min) / 2);
}
else throw new ArgumentNullException("Cannot determine location");
}
return new Tag(element.InternalElement, orientation, tagMode, addLeader,point);
}
/// <summary>
/// Determine if an element lies
/// within the volume of the Room
/// </summary>
public bool IsInRoom(Element element)
{
DB.FamilyInstance familyInstance = element.InternalElement as DB.FamilyInstance;
if (familyInstance != null)
{
if (familyInstance.HasSpatialElementCalculationPoint)
{
DB.XYZ insertionPoint = familyInstance.GetSpatialElementCalculationPoint();
if (InternalRoom.IsPointInRoom(insertionPoint))
{
return true;
}
else
{
return false;
}
}
}
DB.LocationPoint insertionLocationPoint = element.InternalElement.Location as DB.LocationPoint;
if (insertionLocationPoint != null)
{
DB.XYZ insertionPoint = insertionLocationPoint.Point;
if (InternalRoom.IsPointInRoom(insertionPoint))
{
return true;
}
}
return false;
}
/// <summary>
///get curtain grid from element with curtain grid or grids
/// </summary>
/// <param name="curtainHolderElement"></param>
/// <param name="elementFaceReference"></param>
static public CurtainGrid ByElementAndReference(Element curtainHolderElement, ElementFaceReference elementFaceReference)
{
return new CurtainGrid(curtainHolderElement.InternalElement, elementFaceReference.InternalReference);
}
/// <summary>
///get curtain grid from element with curtain grid or grids
/// </summary>
/// <param name="curtainHolderElement"></param>
static public CurtainGrid ByElement( Element curtainHolderElement)
{
return new CurtainGrid(curtainHolderElement.InternalElement);
}
/// <summary>
/// Create a MEP Space
/// from an existing MEP Space
/// </summary>
/// <param name="element">The origin element</param>
/// <returns></returns>
public static Space FromElement(Element element)
{
if (element.InternalElement.GetType() == typeof(DB.Mechanical.Space))
{
return new Space(element.InternalElement as DB.Mechanical.Space);
}
else
{
throw new ArgumentException("The Element is not a MEP Space");
}
}
