/// <summary> /// Finds all the views in the active document. /// </summary> /// <param name="doc">the active document</param> public static ViewSet GetAllViews (Document doc) { ViewSet allViews = new ViewSet(); FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(FloorType)); fec.WherePasses(elementsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { Autodesk.Revit.DB.View view = element as Autodesk.Revit.DB.View; if (null == view) { continue; } else { ElementType objType = doc.GetElement(view.GetTypeId()) as ElementType; if (null == objType || objType.Name.Equals("Drawing Sheet")) { continue; } else { allViews.Insert(view); } } } return allViews; }
public static ElementId CreateJoinedWall(Document doc, ElementId wallId, FamilyInstance familyInstance) { //create a line to represent the wall center line var line = Line.CreateBound(XYZ.Zero, XYZ.BasisX); //find first level var collector = new FilteredElementCollector(doc); var filter = new ElementClassFilter(typeof(Level)); var level = collector.WherePasses(filter).FirstElement() as Level; //create wall var wall = Wall.Create(doc, line, level.Id, false); //save the id so we can delete the wall later wallId = wall.Id; //if the selected element var subIds = familyInstance.GetSubComponentIds(); if (subIds.Count > 0) { foreach (var id in subIds) { var subelement = doc.GetElement(id); JoinGeometryUtils.JoinGeometry(doc, wall, subelement); } } else { JoinGeometryUtils.JoinGeometry(doc, wall, familyInstance); } return(wallId); }
// http://thebuildingcoder.typepad.com/blog/2010/01/findreferencesbydirection.html#comment-4055509541 /// <summary> /// Return reference to ceiling face to place /// lighting fixture above a given point. /// </summary> Reference GetCeilingReferenceAbove( View3D view, XYZ p) { ElementClassFilter filter = new ElementClassFilter( typeof(Ceiling)); ReferenceIntersector refIntersector = new ReferenceIntersector(filter, FindReferenceTarget.Face, view); refIntersector.FindReferencesInRevitLinks = true; ReferenceWithContext rwc = refIntersector.FindNearest( p, XYZ.BasisZ); Reference r = (null == rwc) ? null : rwc.GetReference(); if (null == r) { System.Windows.MessageBox.Show("no intersecting geometry"); } return(r); }
public Result OnStartup(UIControlledApplication a) { //Create Ribbon Panel add the UI button on start up RibbonPanel alignViewsPanel = ribbonPanel(a); //Register location updater with Revit. LocationUpdater updater = new LocationUpdater(a.ActiveAddInId); UpdaterRegistry.RegisterUpdater(updater, true); ElementCategoryFilter viewPortFilter = new ElementCategoryFilter(BuiltInCategory.OST_Viewports); ElementCategoryFilter viewFilter = new ElementCategoryFilter(BuiltInCategory.OST_Views); LogicalOrFilter filter = new LogicalOrFilter(viewPortFilter, viewFilter); //Parameter to send to the trigger. ElementClassFilter viewPort = new ElementClassFilter(typeof(Viewport)); ElementId viewPortNumberId = new ElementId(BuiltInParameter.VIEWPORT_DETAIL_NUMBER); //Set trigger UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), viewPort, Element.GetChangeTypeParameter(viewPortNumberId)); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), filter, Element.GetChangeTypeElementAddition()); //add buttons to ribbon addVRCommandButtons(alignViewsPanel); pushButton_Setting(alignViewsPanel); return Result.Succeeded; }
/// <summary> /// Gather up all the available sheets. /// </summary> /// <param name="doc"></param> /// <param name="sheet"></param> /// <returns></returns> public static ElementSet GetAllSheets(Document doc) { ElementSet allSheets = new ElementSet(); FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(ViewSheet)); fec.WherePasses(elementsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { ViewSheet viewSheet = element as ViewSheet; if (null == viewSheet) { continue; } else { ElementId objId = viewSheet.GetTypeId(); if (ElementId.InvalidElementId == objId) { continue; } else { allSheets.Insert(viewSheet); } } } return allSheets; }
public static Pipe CreateDummyPipe(XYZ pointToConnect, XYZ directionPoint, PointInSpace endInstance, ElementSymbol elementSymbol) { Pipe pipe = null; ElementId pipeTypeId = elementSymbol.PipeType.Id; //Collect levels and select one level FilteredElementCollector levelCollector = new FilteredElementCollector(PCFImport.doc); ElementClassFilter levelFilter = new ElementClassFilter(typeof(Level)); ElementId levelId = levelCollector.WherePasses(levelFilter).FirstElementId(); //Create vector to define pipe XYZ pipeDir = pointToConnect - directionPoint; XYZ helperPoint1 = pointToConnect.Add(pipeDir.Multiply(2)); //Create pipe pipe = Pipe.Create(PCFImport.doc, elementSymbol.PipingSystemType.Id, pipeTypeId, levelId, pointToConnect, helperPoint1); //Set pipe diameter Parameter parameter = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_DIAMETER_PARAM); parameter.Set(endInstance.Diameter); return(pipe); }
public void MarkUntagedFrame() { UIDocument uidoc = ActiveUIDocument; Document doc = uidoc.Document; ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); StructuralMaterialTypeFilter f2 = new StructuralMaterialTypeFilter(StructuralMaterialType.Concrete); ElementClassFilter f3 = new ElementClassFilter(typeof(Floor)); ElementClassFilter f4 = new ElementClassFilter(typeof(Wall)); LogicalAndFilter f5 = new LogicalAndFilter(f1, f2); LogicalOrFilter f6 = new LogicalOrFilter(f3, f4); LogicalOrFilter memberFilter = new LogicalOrFilter(f5, f6); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.WherePasses(memberFilter); List <Element> members = collector.ToList(); String Tag = null; foreach (Element e in members) { Tag = e.get_Parameter(BuiltInParameter.DOOR_NUMBER).AsString(); if (Tag == "" || Tag == null) { HiLighted(e.Id, uidoc, doc); } else { UnHiLighted(e.Id, uidoc, doc); } Tag = null; } }
/// <summary> /// Read all Revit model levels. /// </summary> private void ReadLevels() { var collector = new FilteredElementCollector(a_doc); var filterCategory = new ElementCategoryFilter(BuiltInCategory.OST_Levels); var filterNotSymbol = new ElementClassFilter(typeof(FamilySymbol), true); var filter = new LogicalAndFilter(filterCategory, filterNotSymbol); var elements = collector.WherePasses(filter).ToElements(); var unSortedLevels = new List <Tuple <double, string> >(); foreach (var element in elements) { try { if (element is Level) { var level = element as Level; var levelWork = new Tuple <double, string>(level.ProjectElevation, level.Name); unSortedLevels.Add(levelWork); } } catch (Exception e) { ShowElementErrorMessage(element, e); } } // Sort level data by elevation, bottom to top a_levelData = unSortedLevels.OrderBy(el => el.Item1).ToList(); a_unknownLevelElevation = a_levelData.Count > 0 ? a_levelData[0].Item1 - 100 : 0.0; }
/// <summary> /// Read all Revit model phases. /// </summary> private void ReadPhases() { var collector = new FilteredElementCollector(a_doc); var filterCategory = new ElementCategoryFilter(BuiltInCategory.OST_Phases); var filterNotSymbol = new ElementClassFilter(typeof(FamilySymbol), true); var filter = new LogicalAndFilter(filterCategory, filterNotSymbol); var elements = collector.WherePasses(filter).ToElements(); foreach (var element in elements) { try { if (element is Phase) { bool export = false; if (element.Name.ToUpper().Contains("NEW")) { export = true; } this.a_revitPhases.Add(new RevitPhase(element.Name, export)); } } catch (Exception e) { ShowElementErrorMessage(element, e); } } }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication app = commandData.Application; m_doc = app.ActiveUIDocument.Document; // filter for family instance and (door or window): ElementClassFilter fFamInstClass = new ElementClassFilter(typeof(FamilyInstance)); ElementCategoryFilter fDoorCat = new ElementCategoryFilter(BuiltInCategory.OST_Doors); ElementCategoryFilter fWindowCat = new ElementCategoryFilter(BuiltInCategory.OST_Windows); LogicalOrFilter fCat = new LogicalOrFilter(fDoorCat, fWindowCat); LogicalAndFilter f = new LogicalAndFilter(fCat, fFamInstClass); FilteredElementCollector openings = new FilteredElementCollector(m_doc); openings.WherePasses(f); // map with key = host element id and // value = list of hosted element ids: Dictionary <ElementId, List <ElementId> > ids = GetElementIds(openings); DumpHostedElements(ids); m_doc = null; return(Result.Succeeded); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Document doc = commandData.Application.ActiveUIDocument.Document; double elevation = 3; Transaction trans = new Transaction(doc); trans.Start("creatlevel"); Level level = Level.Create(doc, elevation); trans.Commit(); var classFilter = new ElementClassFilter(typeof(ViewFamilyType)); FilteredElementCollector filterElements = new FilteredElementCollector(doc); filterElements.WherePasses(classFilter); foreach (ViewFamilyType viewFamilyType in filterElements) { if ((viewFamilyType.ViewFamily == ViewFamily.FloorPlan) || (viewFamilyType.ViewFamily == ViewFamily.CeilingPlan)) { trans.Start("creat view of type" + viewFamilyType.ViewFamily); ViewPlan view = ViewPlan.Create(doc, viewFamilyType.Id, level.Id); trans.Commit(); } } return(Autodesk.Revit.UI.Result.Succeeded); }
//***********************************OnStartup*********************************** public Result OnStartup(UIControlledApplication a) { //Updater active using appication id. Updater updater = new Updater(a.ActiveAddInId); //Updater //Register the updater UpdaterRegistry.RegisterUpdater(updater); // Revit elements to trigger ElementClassFilter walls = new ElementClassFilter(typeof(Wall)); ElementClassFilter SE = new ElementClassFilter(typeof(FamilySymbol)); ElementClassFilter MEP = new ElementClassFilter(typeof(MEPSystem)); //Set trigger to send to execute when modified, deleted, gemoetry change or anything. UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), walls, Element.GetChangeTypeElementAddition()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), walls, Element.GetChangeTypeElementDeletion()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), walls, Element.GetChangeTypeGeometry()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), walls, Element.GetChangeTypeAny()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), SE, Element.GetChangeTypeElementAddition()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), SE, Element.GetChangeTypeElementDeletion()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), SE, Element.GetChangeTypeGeometry()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), SE, Element.GetChangeTypeAny()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), MEP, Element.GetChangeTypeElementAddition()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), MEP, Element.GetChangeTypeElementDeletion()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), MEP, Element.GetChangeTypeGeometry()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), MEP, Element.GetChangeTypeAny()); return(Result.Succeeded); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication app = commandData.Application; m_doc = app.ActiveUIDocument.Document; // filter for family instance and (door or window): ElementClassFilter fFamInstClass = new ElementClassFilter( typeof( FamilyInstance ) ); ElementCategoryFilter fDoorCat = new ElementCategoryFilter( BuiltInCategory.OST_Doors ); ElementCategoryFilter fWindowCat = new ElementCategoryFilter( BuiltInCategory.OST_Windows ); LogicalOrFilter fCat = new LogicalOrFilter( fDoorCat, fWindowCat ); LogicalAndFilter f = new LogicalAndFilter( fCat, fFamInstClass ); FilteredElementCollector openings = new FilteredElementCollector( m_doc ); openings.WherePasses( f ); // map with key = host element id and // value = list of hosted element ids: Dictionary<ElementId, List<ElementId>> ids = GetElementIds( openings ); DumpHostedElements( ids ); m_doc = null; return Result.Succeeded; }
private void CreateInstancesAndSetLocations(List <XYZ> locations, Room room) { FilteredElementCollector collector = new FilteredElementCollector(Doc); Func <View3D, bool> isNotTemplate = v3 => !(v3.IsTemplate); View3D view3D = collector.OfClass(typeof(View3D)).Cast <View3D>().First <View3D>(isNotTemplate); BoundingBoxXYZ box = room.get_BoundingBox(view3D); XYZ center = box.Min.Add(box.Max).Multiply(0.5); // Project in the negative Z direction down to the floor. XYZ rayDirection = new XYZ(0, 0, 1); ElementClassFilter filter = new ElementClassFilter(typeof(Floor)); ReferenceIntersector refIntersector = new ReferenceIntersector(filter, FindReferenceTarget.Face, view3D); ReferenceWithContext referenceWithContext = refIntersector.FindNearest(center, rayDirection); Reference reference = referenceWithContext.GetReference(); var el = Doc.GetElement(reference); var ids = string.Empty; var vector = new XYZ(1, 0, 0); for (int i = 0; i < locations.Count; i++) { var fi = App.ActiveUIDocument.Document.Create.NewFamilyInstance(reference, locations[i], vector, this.symbol); ids += fi.Id.IntegerValue.ToString() + ";"; } }
public static List <Room> GetModelRoomsActView(Document doc) { List <Room> modelRooms = new List <Room>(); ElementClassFilter classFilter = new ElementClassFilter(typeof(SpatialElement)); IEnumerable <SpatialElement> seRooms = new FilteredElementCollector(doc, doc.ActiveView.Id) .OfCategory(BuiltInCategory.OST_Rooms) .WherePasses(classFilter) .Cast <SpatialElement>() .Where(se => se.Location != null); foreach (SpatialElement se in seRooms) { try { Room r = se as Room; if (r != null) { modelRooms.Add(r); } } catch (Exception) { continue; } } return(modelRooms); }
private static void ExtractObjects() { FilteredElementCollector CeilingCollector = new FilteredElementCollector(_doc); ElementClassFilter CeilingFilter = new ElementClassFilter(typeof(Ceiling)); _Ceiling = CeilingCollector.WherePasses(CeilingFilter).ToList(); }
/// <summary> /// Finds all the views in the active document. /// </summary> /// <param name="doc">the active document</param> public static ViewSet GetAllViews(Document doc) { ViewSet allViews = new ViewSet(); FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(FloorType)); fec.WherePasses(elementsAreWanted); List <Element> elements = fec.ToElements() as List <Element>; foreach (Element element in elements) { Autodesk.Revit.DB.View view = element as Autodesk.Revit.DB.View; if (null == view) { continue; } else { ElementType objType = doc.GetElement(view.GetTypeId()) as ElementType; if (null == objType || objType.Name.Equals("Drawing Sheet")) { continue; } else { allViews.Insert(view); } } } return(allViews); }
/// <summary> /// Gets a representative view generated by the level. /// </summary> /// <param name="document">The document.</param> /// <param name="viewType">The view type.</param> /// <param name="level">The level.</param> /// <returns>A view associate with the level.</returns> /// <remarks>This function will return the first view it finds with a bottom range set to an offset of the generating level. /// If no such view is found, but a view based on the generating level exists, that view will be returned.</remarks> public static View FindViewByLevel(Document document, ViewType viewType, Level level) { View possibleView = null; ElementFilter elementFilter = new ElementClassFilter(typeof(View)); FilteredElementCollector collector = new FilteredElementCollector(document); collector.WherePasses(elementFilter); foreach (View view in collector) { if (view.ViewType != viewType) { continue; } if (view.GenLevel != null && view.GenLevel.Id == level.Id) { PlanViewRange viewRange = (view as ViewPlan).GetViewRange(); ElementId bottomClipPlaneId = viewRange.GetLevelId(PlanViewPlane.BottomClipPlane); if (bottomClipPlaneId != level.Id) { possibleView = view; continue; } return(view); } } return(possibleView); }
public void MarkFrames() { UIDocument uidoc = ActiveUIDocument; Document doc = uidoc.Document; ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); StructuralMaterialTypeFilter f2 = new StructuralMaterialTypeFilter(StructuralMaterialType.Concrete); ElementClassFilter f3 = new ElementClassFilter(typeof(Floor)); ElementClassFilter f4 = new ElementClassFilter(typeof(Wall)); LogicalAndFilter f5 = new LogicalAndFilter(f1, f2); LogicalOrFilter f6 = new LogicalOrFilter(f3, f4); LogicalOrFilter memberFilter = new LogicalOrFilter(f5, f6); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.WherePasses(memberFilter); List <Element> members = collector.ToList(); int SN = 1; using (Transaction tx = new Transaction(doc, "MarkFrames")){ tx.Start(); foreach (Element e in members) { e.get_Parameter(BuiltInParameter.DOOR_NUMBER).Set("C" + SN.ToString("00")); SN++; } tx.Commit(); } }
public void ClearMarks() { Document doc = this.ActiveUIDocument.Document; FilteredElementCollector collector = new FilteredElementCollector(doc); ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); StructuralMaterialTypeFilter f2 = new StructuralMaterialTypeFilter(StructuralMaterialType.Concrete); ElementClassFilter f3 = new ElementClassFilter(typeof(Floor)); ElementClassFilter f4 = new ElementClassFilter(typeof(Wall)); LogicalAndFilter f5 = new LogicalAndFilter(f1, f2); LogicalOrFilter f6 = new LogicalOrFilter(f3, f4); LogicalOrFilter f7 = new LogicalOrFilter(f5, f6); ICollection <Element> collection = collector.WherePasses(f7).ToElements(); using (Transaction tx = new Transaction(doc, "CopyMarkToSN")) { tx.Start(); foreach (Element e in collection) { Parameter pSN = e.LookupParameter("編號"); if (null != pSN) { // Parameter pMark = e.LookupParameter("標註"); Parameter pMark = e.get_Parameter(BuiltInParameter.DOOR_NUMBER); pMark.Set(""); } } tx.Commit(); } }
public void MarkReverseColumn() { UIDocument uidoc = ActiveUIDocument; Document doc = uidoc.Document; ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.WherePasses(f1); List <Element> columns = collector.Where(q => q.Category.Name == "結構柱").ToList(); foreach (Element e in columns) { Level BottomLevel = doc.GetElement(e.LookupParameter("基準樓層").AsElementId()) as Level; Level TopLevel = doc.GetElement(e.LookupParameter("頂部樓層").AsElementId()) as Level; double BottomElevation = e.LookupParameter("基準偏移").AsDouble() + BottomLevel.Elevation; double TopElevation = e.LookupParameter("頂部偏移").AsDouble() + TopLevel.Elevation; if (TopElevation < BottomElevation) { HiLighted(e.Id, uidoc, doc); } else { UnHiLighted(e.Id, uidoc, doc); } } }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Document doc = commandData.Application.ActiveUIDocument.Document; ElementFilter door_Category = new ElementCategoryFilter(BuiltInCategory.OST_Doors); //获取门类别 ElementFilter door_FamilyInstance = new ElementClassFilter(typeof(FamilyInstance)); //获取族实例 LogicalAndFilter doorFamilyInstance = new LogicalAndFilter(door_Category, door_FamilyInstance); FilteredElementCollector doorFiltered = new FilteredElementCollector(doc).WherePasses(doorFamilyInstance); IList <Element> door_elements = doorFiltered.ToElements(); ParameterSet paras = null; foreach (Element elems in door_elements) { paras = elems.Parameters; } string paraName = ""; foreach (Parameter para in paras) { paraName += "\n\t" + para.Definition.Name; } File.WriteAllText(@"D:\door.txt", paraName); return(Result.Succeeded); }
Execute () { //Get every level by iterating through all elements systemLevelsData = new List<LevelsDataSource>(); FilteredElementCollector fec = new FilteredElementCollector(m_app.ActiveUIDocument.Document); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(Level)); fec.WherePasses(elementsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { Level systemLevel = element as Level; if (systemLevel != null) { LevelsDataSource levelsDataSourceRow = new LevelsDataSource(); levelsDataSourceRow.LevelIDValue = systemLevel.Id.IntegerValue; levelsDataSourceRow.Name = systemLevel.Name; levelsDataSourceRow.Elevation = systemLevel.Elevation; systemLevelsData.Add(levelsDataSourceRow); } } LevelsForm displayForm = new LevelsForm(this); displayForm.ShowDialog(); return true; }
GetAvailableViewsToExport(Document doc) { ViewSet viewSet = new ViewSet(); // TBD: using a filter iterator will only give you the base class View, not derived classes // like View3D or ViewDrafting. /*ElementFilterIterator viewIter = m_revitApp.ActiveUIDocument.Document.GetElements(typeof(Autodesk.Revit.DB.View)); * while (viewIter.MoveNext()) { * Autodesk.Revit.DB.View tmpView = (Autodesk.Revit.DB.View)viewIter.Current; * if (tmpView.CanBePrinted) * viewSet.Insert((Autodesk.Revit.DB.View)viewIter.Current); * }*/ FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(View)); fec.WherePasses(elementsAreWanted); List <Element> elements = fec.ToElements() as List <Element>; foreach (Element element in elements) { Autodesk.Revit.DB.View tmpView = element as Autodesk.Revit.DB.View; if ((tmpView != null) && tmpView.CanBePrinted) { viewSet.Insert(tmpView); } } return(viewSet); }
private static bool RegisterSheetUpdater(Document doc, ref SheetManagerConfiguration config) { bool registered = false; try { Guid updaterGuid = Guid.NewGuid(); SheetUpdater sheetUpdater = new SheetUpdater(addinId, updaterGuid, config); sheetUpdater.CollectCustomSheetParamIds(doc); sheetUpdater.CollectIdMaps(doc); UpdaterRegistry.RegisterUpdater(sheetUpdater, doc); ElementClassFilter sheetFilter = new ElementClassFilter(typeof(ViewSheet)); UpdaterRegistry.AddTrigger(sheetUpdater.GetUpdaterId(), sheetFilter, Element.GetChangeTypeElementAddition()); UpdaterRegistry.AddTrigger(sheetUpdater.GetUpdaterId(), sheetFilter, Element.GetChangeTypeElementDeletion()); foreach (ElementId paramId in sheetUpdater.SheetParameters.Keys) { UpdaterRegistry.AddTrigger(sheetUpdater.GetUpdaterId(), sheetFilter, Element.GetChangeTypeParameter(paramId)); } if (!sheetUpdaters.ContainsKey(config.ModelId)) { sheetUpdaters.Add(config.ModelId, sheetUpdater); } registered = true; } catch (Exception ex) { MessageBox.Show("Failed to register sheet updater.\n" + ex.Message, "Register Sheet Updater", MessageBoxButton.OK, MessageBoxImage.Warning); } return(registered); }
public void prependViewTemplateNames() { UIDocument uiDoc = this.ActiveUIDocument; Document dbDoc = this.ActiveUIDocument.Document; String prependString = Prompt.ShowDialog("String to prepend: ", "Prepend View Template Names"); ElementClassFilter viewFilter = new ElementClassFilter(typeof(Autodesk.Revit.DB.View)); FilteredElementCollector collector = new FilteredElementCollector(dbDoc); IEnumerable <Autodesk.Revit.DB.View> allViews = collector.WherePasses(viewFilter).Cast <Autodesk.Revit.DB.View>().AsEnumerable(); var viewTemplates = allViews.Where(t => t.IsTemplate); using (Transaction t = new Transaction(dbDoc, "Prepend View Template Names")) { t.Start(); foreach (var vt in viewTemplates) { vt.Name = (prependString + vt.Name); } t.Commit(); } }
Execute() { //Get every level by iterating through all elements systemLevelsData = new List <LevelsDataSource>(); FilteredElementCollector fec = new FilteredElementCollector(m_app.ActiveUIDocument.Document); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(Level)); fec.WherePasses(elementsAreWanted); List <Element> elements = fec.ToElements() as List <Element>; foreach (Element element in elements) { Level systemLevel = element as Level; if (systemLevel != null) { LevelsDataSource levelsDataSourceRow = new LevelsDataSource(); levelsDataSourceRow.LevelIDValue = systemLevel.Id.IntegerValue; levelsDataSourceRow.Name = systemLevel.Name; levelsDataSourceRow.Elevation = systemLevel.Elevation; systemLevelsData.Add(levelsDataSourceRow); } } LevelsForm displayForm = new LevelsForm(this); displayForm.ShowDialog(); return(true); }
GetAllSheets(Document doc) { ElementSet allSheets = new ElementSet(); FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(ViewSheet)); fec.WherePasses(elementsAreWanted); List <Element> elements = fec.ToElements() as List <Element>; foreach (Element element in elements) { ViewSheet viewSheet = element as ViewSheet; if (null == viewSheet) { continue; } else { ElementId objId = viewSheet.GetTypeId(); if (ElementId.InvalidElementId == objId) { continue; } else { allSheets.Insert(viewSheet); } } } return(allSheets); }
private List <double> GetDistancesToFloors(Document doc, View3D view3D, Room room) { LocationPoint point = room.Location as LocationPoint; XYZ origin = point.Point; XYZ center = new XYZ(point.Point.X, point.Point.Y, point.Point.Z + 0.01); // Project in the positive Z direction up to the floor. XYZ rayDirection = new XYZ(0, 0, 1); ElementClassFilter filter = new ElementClassFilter(typeof(Floor)); ReferenceIntersector refIntersector = new ReferenceIntersector(filter, FindReferenceTarget.Face, view3D); refIntersector.FindReferencesInRevitLinks = true; IList <ReferenceWithContext> referencesWithContext = refIntersector.Find(center, rayDirection); IList <Reference> intersectRefs = new List <Reference>(); Dictionary <Reference, XYZ> dictProvisionForVoidRefs = new Dictionary <Reference, XYZ>(); List <double> result = new List <double>(); foreach (ReferenceWithContext r in referencesWithContext) { XYZ intersection = r.GetReference().GlobalPoint; Line line = Line.CreateBound(origin, intersection); result.Add(line.Length); } result.Sort(); return(result); }
/// <summary> /// iterate all the symbols of levels and beams /// </summary> /// <returns>A value that signifies if the initialization was successful for true or failed for false</returns> private bool Initialize() { try { ElementClassFilter levelFilter = new ElementClassFilter(typeof(Level)); ElementClassFilter famFilter = new ElementClassFilter(typeof(Family)); LogicalOrFilter orFilter = new LogicalOrFilter(levelFilter, famFilter); FilteredElementCollector collector = new FilteredElementCollector(m_revit.ActiveUIDocument.Document); FilteredElementIterator i = collector.WherePasses(orFilter).GetElementIterator(); i.Reset(); bool moreElement = i.MoveNext(); while (moreElement) { object o = i.Current; // add level to list Level level = o as Level; if (null != level) { m_levels.Add(new LevelMap(level)); goto nextLoop; } // get Family f = o as Family; if (null == f) { goto nextLoop; } foreach (ElementId elementId in f.GetFamilySymbolIds()) { object symbol = m_revit.ActiveUIDocument.Document.GetElement(elementId); FamilySymbol familyType = symbol as FamilySymbol; if (null == familyType) { goto nextLoop; } if (null == familyType.Category) { goto nextLoop; } // add symbols of beams and braces to lists string categoryName = familyType.Category.Name; if ("Structural Framing" == categoryName) { m_beamMaps.Add(new SymbolMap(familyType)); } } nextLoop: moreElement = i.MoveNext(); } } catch (Exception ex) { throw new Exception(ex.ToString()); } return(true); }
//***********************************GetFamilySymbols*********************************** public List <FamilyInstance> GetFamilyInstance(Document doc, string name, BuiltInCategory category) { List <FamilyInstance> List_FamilyInstance = new List <FamilyInstance>(); ElementClassFilter familyInstanceFilter = new ElementClassFilter(typeof(FamilyInstance)); // Category filter ElementCategoryFilter Categoryfilter = new ElementCategoryFilter(category); // Instance filter LogicalAndFilter InstancesFilter = new LogicalAndFilter(familyInstanceFilter, Categoryfilter); FilteredElementCollector collector = new FilteredElementCollector(doc); // Colletion Array of Elements ICollection <Element> Elements = collector.WherePasses(InstancesFilter).ToElements(); foreach (Element e in Elements) { FamilyInstance familyInstance = e as FamilyInstance; if (null != familyInstance) { try { if (familyInstance.Name.Contains(name)) { List_FamilyInstance.Add(familyInstance); } } catch (Exception ex) { string x = ex.Message; } } } return(List_FamilyInstance); }
//reate and Register Dynamic Model Updaters with the Current Session of Revit. It should only need to be registered one time per session, and affects //all documents opened there after private Result RegisterUpdaters(UIControlledApplication RevitApplication) { try { //Create a new instance of the ViewSheetUpdater Class and Pass the ActiveAddInId for this Application Updaters.ViewSheetUpdater viewSheetUpdater = new Updaters.ViewSheetUpdater(RevitApplication.ActiveAddInId); //Register the Updater for this Session of Revit. The IsOption bool at the end allows the modifications of the updater to persist even if another user //doesnt have the same add-in (For paid / propriatary add-in like Autodesk Subcription itsm) UpdaterRegistry.RegisterUpdater(viewSheetUpdater, true); //Filter the items being "watched" to just ViewSheets so we use a class filter ElementClassFilter viewSheetFilter = new ElementClassFilter(typeof(ViewSheet)); //Add a trigger to the Updater so Revit knows When to execute the Updater. Here it is set for Element Addition //which is when a new sheet is created. UpdaterRegistry.AddTrigger(viewSheetUpdater.GetUpdaterId(), viewSheetFilter, Element.GetChangeTypeElementAddition()); //This Method is set up as a Result becuase you may need to Unregister and Re-Register the updaters for other portions of the App and //it is good to know if it all worked or not return(Result.Succeeded); } //Catch any exceptions and present them to the User catch (Exception ex) { TaskDialog.Show("Error Registering Updaters", ex.ToString()); return(Result.Failed); } }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { var uiApp = commandData.Application; var uiDoc = uiApp.ActiveUIDocument; var app = uiApp.Application; var doc = uiDoc.Document; // Start code here // Lay nhung doi tuong dang chon try { var familyInstanceFilter = new ElementClassFilter(typeof(FamilyInstance)); var doorsCategoryFilter = new ElementCategoryFilter(BuiltInCategory.OST_Doors); var listFilter = new List <ElementFilter>() { new ElementCategoryFilter(BuiltInCategory.OST_Doors) }; //var doorInstancesFilters = new LogicalAndFilter(listFilter); var doorInstancesFilters = new LogicalAndFilter(familyInstanceFilter, doorsCategoryFilter); var collector = new FilteredElementCollector(doc); var doors = collector.WherePasses(doorInstancesFilters).ToElements(); TaskDialog.Show("Door Count", doors.Count().ToString()); return(Result.Succeeded); } catch (Exception e) { message = e.Message; return(Result.Failed); } }
/// <summary> /// Delete all unnecessary lines /// </summary> public void DeleteLines() { int delLineNum = 0; try { SubTransaction transaction = new SubTransaction(m_app.ActiveUIDocument.Document); transaction.Start(); List <Autodesk.Revit.DB.Element> list = new List <Autodesk.Revit.DB.Element>(); ElementClassFilter filter = new ElementClassFilter(typeof(Autodesk.Revit.DB.CurveElement)); FilteredElementCollector collector = new FilteredElementCollector(m_app.ActiveUIDocument.Document); list.AddRange(collector.WherePasses(filter).ToElements()); foreach (Autodesk.Revit.DB.Element e in list) { ModelCurve mc = e as ModelCurve; if (mc != null) { if (mc.LineStyle.Name == "bounce" || mc.LineStyle.Name == "normal") { m_app.ActiveUIDocument.Document.Delete(e.Id); delLineNum++; } } } transaction.Commit(); } catch (System.Exception) { } }
private FloorType FindFloorType(Room room) { FloorType floorType = null; try { var typeName = room.get_Parameter(BuiltInParameter.ROOM_FINISH_FLOOR).AsString(); var collector = new FilteredElementCollector(m_doc); var classFilter = new ElementClassFilter(typeof(FloorType)); collector.WherePasses(classFilter); var query = from element in collector where element.Name == typeName select element; var floorTypes = query.Cast <FloorType>().ToList <FloorType>(); if (floorTypes.Count > 0) { floorType = floorTypes[0]; } if (floorTypes.Count == 0) { floorType = CreateFloorType(room, typeName); } } catch (Exception ex) { MessageBox.Show("Cannot find the floor type.\n" + ex.Message, "Find Floor Type", MessageBoxButtons.OK, MessageBoxIcon.Warning); } return(floorType); }
private static void ExtractObjects() { ElementFilter ductFilter = new ElementCategoryFilter(BuiltInCategory.OST_DuctCurves); ElementFilter faminsFilter = new ElementClassFilter(typeof(MEPCurve)); FilteredElementCollector ductCollector = new FilteredElementCollector(_doc); ductCollector.WherePasses(ductFilter).WherePasses(faminsFilter); foreach (MEPCurve duct in ductCollector) _ducts.Add(duct); }
private static void ExtractObjects() { List<ElementId> materials = null; Material material = null; ElementFilter WallFilter = new ElementCategoryFilter(BuiltInCategory.OST_Walls); ElementFilter NonStruWallFilter = new StructuralWallUsageFilter(StructuralWallUsage.NonBearing); ElementFilter WallClassFilter = new ElementClassFilter(typeof(Wall)); FilteredElementCollector GypWalls = new FilteredElementCollector(_doc); GypWalls.WherePasses(WallFilter).WherePasses(NonStruWallFilter); int[] count1 = new int[2]; //0:Gyp, 1:wallpaper, 2:ceramic foreach (Wall wall in GypWalls) { materials = wall.GetMaterialIds(false).ToList(); foreach (ElementId eleId in materials) { material = _doc.GetElement(eleId) as Material; if (material.MaterialCategory == _addiInfo.materialTypes[(byte)PGMaterialType.Gypsum]) ++count1[0]; else if (material.MaterialCategory == _addiInfo.materialTypes[(byte)PGMaterialType.WallPaper]) ++count1[1]; else if (material.MaterialCategory == _addiInfo.materialTypes[(byte)PGMaterialType.Ceramic]) ++count1[2]; } //assert: count1[i] is non-negative if (count1[0] == 0) continue; if (count1[1] == 0 && count1[2] == 0) _GypWalls.Add(new RichWall(wall,FinishType.None)); else if(count1[2] == 0) //assert: count1[1] != 0 { if (count1[1] == 1) _GypWalls.Add(new RichWall(wall,FinishType.OneWallpaper)); else if (count1[1] == 2) _GypWalls.Add(new RichWall(wall,FinishType.TwoWallpaper)); } else if(count1[1] == 0) //assert: count1[2] != 0 { if (count1[2] == 1) _GypWalls.Add(new RichWall(wall,FinishType.OneCeramic)); else if (count1[2] == 2) _GypWalls.Add(new RichWall(wall,FinishType.TwoCeramic)); } else _abandonWriter.WriteAbandonment(wall, AbandonmentTable.TooManyFinishes); } if (_addiInfo.requiredComp[(byte)PGComponents.WallFinish]) { int count2 = 0; FilteredElementCollector GeneticWalls = new FilteredElementCollector(_doc); GeneticWalls.WherePasses(WallFilter).WherePasses(WallClassFilter); foreach (Wall wall in GeneticWalls) { materials = wall.GetMaterialIds(false).ToList(); foreach (ElementId eleId in materials) { material = _doc.GetElement(eleId) as Material; if (material.MaterialCategory == _addiInfo.materialTypes[(byte)PGMaterialType.Wood] || material.MaterialCategory == _addiInfo.materialTypes[(byte)PGMaterialType.Marble]) ++count2; } if (count2 == 1) _GeneticWalls.Add(new RichWall(wall,FinishType.OneWood)); else if (count2 == 2) _GeneticWalls.Add(new RichWall(wall,FinishType.TwoWood)); else if (2 <= count2) _abandonWriter.WriteAbandonment(wall, AbandonmentTable.TooManyFinishes); } } }
public static IList<Element> OfElementType(Type elementType) { var elFilter = new ElementClassFilter(elementType); var fec = new FilteredElementCollector(DocumentManager.Instance.CurrentDBDocument); fec.WherePasses(elFilter); var instances = fec.ToElements() .Select(x => ElementSelector.ByElementId(x.Id.IntegerValue)).ToList(); return instances; }
/// <summary> /// Implement this method as an external command for Revit. /// </summary> /// <param name="commandData">An object that is passed to the external application /// which contains data related to the command, /// such as the application object and active view.</param> /// <param name="message">A message that can be set by the external application /// which will be displayed if a failure or cancellation is returned by /// the external command.</param> /// <param name="elements">A set of elements to which the external application /// can add elements that are to be highlighted in case of failure or cancellation.</param> /// <returns>Return the status of the external command. /// A result of Succeeded means that the API external method functioned as expected. /// Cancelled can be used to signify that the user cancelled the external operation /// at some point. Failure should be returned if the application is unable to proceed with /// the operation.</returns> public virtual Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData , ref string message, Autodesk.Revit.DB.ElementSet elements) { Autodesk.Revit.DB.Document doc = commandData.Application.ActiveUIDocument.Document; // get all PanelScheduleView instances in the Revit document. FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter PanelScheduleViewsAreWanted = new ElementClassFilter(typeof(PanelScheduleView)); fec.WherePasses(PanelScheduleViewsAreWanted); List<Element> psViews = fec.ToElements() as List<Element>; bool noPanelScheduleInstance = true; foreach (Element element in psViews) { PanelScheduleView psView = element as PanelScheduleView; if (psView.IsPanelScheduleTemplate()) { // ignore the PanelScheduleView instance which is a template. continue; } else { noPanelScheduleInstance = false; } // choose what format export to, it can be CSV or HTML. TaskDialog alternativeDlg = new TaskDialog("Choose Format to export"); alternativeDlg.MainContent = "Click OK to export in .CSV format, Cancel to export in HTML format."; alternativeDlg.CommonButtons = TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel; alternativeDlg.AllowCancellation = true; TaskDialogResult exportToCSV = alternativeDlg.Show(); Translator translator = TaskDialogResult.Cancel == exportToCSV ? new HTMLTranslator(psView) : new CSVTranslator(psView) as Translator; string exported = translator.Export(); // open the file if export successfully. if (!string.IsNullOrEmpty(exported)) { System.Diagnostics.Process.Start(exported); } } if (noPanelScheduleInstance) { TaskDialog messageDlg = new TaskDialog("Warnning Message"); messageDlg.MainIcon = TaskDialogIcon.TaskDialogIconWarning; messageDlg.MainContent = "No panel schedule view is in the current document."; messageDlg.Show(); return Result.Cancelled; } return Result.Succeeded; }
public static IList<Element> OfFamilyType(FamilySymbol familyType) { var instanceFilter = new ElementClassFilter(typeof(Autodesk.Revit.DB.FamilyInstance)); var fec = new FilteredElementCollector(DocumentManager.Instance.CurrentDBDocument); var familyInstances = fec.WherePasses(instanceFilter) .WhereElementIsNotElementType() .ToElements() .Cast<Autodesk.Revit.DB.FamilyInstance>() .Where(x => x.Symbol.IsSimilarType(familyType.InternalFamilySymbol.Id)); var instances = familyInstances .Select(x => ElementSelector.ByElementId(x.Id.IntegerValue)).ToList(); return instances; }
/// <summary> /// Finds all windows in the active document. /// </summary> /// <returns>An enumerable containing all windows.</returns> protected IEnumerable<FamilyInstance> CollectWindows() { // Windows are family instances whose category is correctly set. ElementClassFilter familyInstanceFilter = new ElementClassFilter(typeof(FamilyInstance)); ElementCategoryFilter windowCategoryFilter = new ElementCategoryFilter(BuiltInCategory.OST_Windows); LogicalAndFilter andFilter = new LogicalAndFilter(familyInstanceFilter, windowCategoryFilter); FilteredElementCollector collector = new FilteredElementCollector(Document); ICollection<Element> elementsToProcess = collector.WherePasses(andFilter).ToElements(); // Convert to IEnumerable of FamilyInstance using LINQ IEnumerable<FamilyInstance> windows = from window in elementsToProcess.Cast<FamilyInstance>() select window; return windows; }
/// <summary> /// Given an Enumerable set of Elements, walk through them and filter out the ones of a specific /// category. /// </summary> /// <param name="filterForCategoryEnum">The BuiltInCategory enum to filter for</param> /// <param name="doc">The current Document object</param> /// <returns>The filtered ElementSet</returns> public static ElementSet FilterToCategory(BuiltInCategory filterForCategoryEnum, bool includeSymbols, Document doc) { ElementSet elemSet = new ElementSet(); FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(Element)); fec.WherePasses(elementsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { elemSet.Insert(element); } return FilterToCategory(elemSet, filterForCategoryEnum, includeSymbols, doc); }
/// <summary> /// Implement this method as an external command for Revit. /// </summary> /// <param name="commandData">An object that is passed to the external application /// which contains data related to the command, /// such as the application object and active view.</param> /// <param name="message">A message that can be set by the external application /// which will be displayed if a failure or cancellation is returned by /// the external command.</param> /// <param name="elements">A set of elements to which the external application /// can add elements that are to be highlighted in case of failure or cancellation.</param> /// <returns>Return the status of the external command. /// A result of Succeeded means that the API external method functioned as expected. /// Cancelled can be used to signify that the user cancelled the external operation /// at some point. Failure should be returned if the application is unable to proceed with /// the operation.</returns> public virtual Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData , ref string message, Autodesk.Revit.DB.ElementSet elements) { Autodesk.Revit.DB.Document doc = commandData.Application.ActiveUIDocument.Document; // get one sheet view to place panel schedule. ViewSheet sheet = doc.ActiveView as ViewSheet; if (null == sheet) { message = "please go to a sheet view."; return Result.Failed; } // get all PanelScheduleView instances in the Revit document. FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter PanelScheduleViewsAreWanted = new ElementClassFilter(typeof(PanelScheduleView)); fec.WherePasses(PanelScheduleViewsAreWanted); List<Element> psViews = fec.ToElements() as List<Element>; Transaction placePanelScheduleOnSheet = new Transaction(doc, "placePanelScheduleOnSheet"); placePanelScheduleOnSheet.Start(); XYZ nextOrigin = new XYZ(0.0, 0.0, 0.0); foreach (Element element in psViews) { PanelScheduleView psView = element as PanelScheduleView; if (psView.IsPanelScheduleTemplate()) { // ignore the PanelScheduleView instance which is a template. continue; } PanelScheduleSheetInstance onSheet = PanelScheduleSheetInstance.Create(doc, psView.Id, sheet); onSheet.Origin = nextOrigin; BoundingBoxXYZ bbox = onSheet.get_BoundingBox(doc.ActiveView); double width = bbox.Max.X - bbox.Min.X; nextOrigin = new XYZ(onSheet.Origin.X + width, onSheet.Origin.Y, onSheet.Origin.Z); } placePanelScheduleOnSheet.Commit(); return Result.Succeeded; }
public Result OnStartup(UIControlledApplication a) { DeletionUpdater deletionUpdater = new DeletionUpdater(a.ActiveAddInId); UpdaterRegistry.RegisterUpdater( deletionUpdater); ElementClassFilter filter = new ElementClassFilter( typeof(Dimension), true); UpdaterRegistry.AddTrigger( deletionUpdater.GetUpdaterId(), filter, Element.GetChangeTypeElementDeletion()); //FailureDefinitionRegistry return Result.Succeeded; }
/// <summary> /// populate with levels /// </summary> private void InitializeListView() { FilteredElementCollector fec = new FilteredElementCollector(m_app.ActiveUIDocument.Document); ElementClassFilter levelsAreWanted = new ElementClassFilter(typeof(Level)); fec.WherePasses(levelsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { Autodesk.Revit.DB.Level sysLevel = element as Autodesk.Revit.DB.Level; if (sysLevel != null) { ListViewItem lev = new ListViewItem(sysLevel.Name); lev.SubItems.Add(sysLevel.Elevation.ToString()); lev.Tag = sysLevel; m_levlv.Items.Add(lev); } } }
private void docOpen(object sender, DocumentOpenedEventArgs e) { Autodesk.Revit.ApplicationServices.Application app = sender as Autodesk.Revit.ApplicationServices.Application; UIApplication uiApp = new UIApplication(app); Document doc = uiApp.ActiveUIDocument.Document; FilteredElementCollector collector = new FilteredElementCollector(doc); collector.WherePasses(new ElementClassFilter(typeof(FamilyInstance))); var sphereElements = from element in collector where element.Name == "sphere" select element; if (sphereElements.Count() == 0) { TaskDialog.Show("Error", "Sphere family must be loaded"); return; } FamilyInstance sphere = sphereElements.Cast<FamilyInstance>().First<FamilyInstance>(); FilteredElementCollector viewCollector = new FilteredElementCollector(doc); ICollection<Element> views = viewCollector.OfClass(typeof(View3D)).ToElements(); var viewElements = from element in viewCollector where element.Name == "AVF" select element; if (viewElements.Count() == 0) { TaskDialog.Show("Error", "A 3D view named 'AVF' must exist to run this application."); return; } View view = viewElements.Cast<View>().First<View>(); SpatialFieldUpdater updater = new SpatialFieldUpdater(uiApp.ActiveAddInId, sphere.Id, view.Id); if (!UpdaterRegistry.IsUpdaterRegistered(updater.GetUpdaterId())) UpdaterRegistry.RegisterUpdater(updater); ElementCategoryFilter wallFilter = new ElementCategoryFilter(BuiltInCategory.OST_Walls); ElementClassFilter familyFilter = new ElementClassFilter(typeof(FamilyInstance)); ElementCategoryFilter massFilter = new ElementCategoryFilter(BuiltInCategory.OST_Mass); IList<ElementFilter> filterList = new List<ElementFilter>(); filterList.Add(wallFilter); filterList.Add(familyFilter); filterList.Add(massFilter); LogicalOrFilter filter = new LogicalOrFilter(filterList); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), filter, Element.GetChangeTypeGeometry()); UpdaterRegistry.AddTrigger(updater.GetUpdaterId(), filter, Element.GetChangeTypeElementDeletion()); }
public Result OnStartup(UIControlledApplication application) { AddRibbonPanel(application); // Failure Definition Registry // Implemented in Prevent Deletion Tool PreventDeletionUpdater deletionUpdater = new PreventDeletionUpdater(application.ActiveAddInId); UpdaterRegistry.RegisterUpdater( deletionUpdater); ElementClassFilter filter = new ElementClassFilter( typeof(Dimension), true); UpdaterRegistry.AddTrigger( deletionUpdater.GetUpdaterId(), filter, Element.GetChangeTypeElementDeletion()); return Result.Succeeded; }
public void CanCreateAndDeleteAReferencePoint() { using (var trans = new Transaction(RevitData.Document.Document, "CreateAndDeleteAreReferencePoint")) { trans.Start(); FailureHandlingOptions fails = trans.GetFailureHandlingOptions(); fails.SetClearAfterRollback(true); trans.SetFailureHandlingOptions(fails); ReferencePoint rp = dynRevitSettings.Doc.Document.FamilyCreate.NewReferencePoint(new XYZ()); //make a filter for reference points. ElementClassFilter ef = new ElementClassFilter(typeof(ReferencePoint)); FilteredElementCollector fec = new FilteredElementCollector(dynRevitSettings.Doc.Document); fec.WherePasses(ef); Assert.AreEqual(1, fec.ToElements().Count()); RevitData.Document.Document.Delete(rp); trans.Commit(); } }
/// <summary> /// This function gets all the walls in the current Revit document /// </summary> /// <param name="startNewTransaction">whether do the filtering in a new transaction</param> /// <returns>the walls</returns> private static IList<Element> GetAllWallElements(bool startNewTransaction) { if (startNewTransaction) { using (var trans = new Transaction(DocumentManager.Instance.CurrentUIDocument.Document, "FilteringElements")) { trans.Start(); ElementClassFilter ef = new ElementClassFilter(typeof(Wall)); FilteredElementCollector fec = new FilteredElementCollector(DocumentManager.Instance.CurrentUIDocument.Document); fec.WherePasses(ef); trans.Commit(); return fec.ToElements(); } } else { ElementClassFilter ef = new ElementClassFilter(typeof(Wall)); FilteredElementCollector fec = new FilteredElementCollector(DocumentManager.Instance.CurrentUIDocument.Document); fec.WherePasses(ef); return fec.ToElements(); } }
/// <summary> /// Used by the SimpleShed to create its floors and the fake roof /// </summary> /// <param name="profile"></param> public Revit.ElementId SimpleFloor( CurveArray profile, Level level ) { Autodesk.Revit.Creation.Document doc = m_revitApp.ActiveUIDocument.Document.Create; Autodesk.Revit.Creation.Application applic = m_revitApp.Application.Create; // Obtain the required floor type FloorType floorType = null; try { FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( FloorType ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { FloorType fType = element as FloorType; if( fType == null ) { continue; } if( fType.Name == "Generic - 12\"" ) { floorType = fType; } } } catch( Exception e ) { throw e; } // Set the stuctural value bool structural = true; Revit.ElementId elemId = new ElementId( 0 ); // Create the floor instance try { if( level.Name == "Level 2" ) { level.Elevation = 10.0; Floor f = doc.NewFloor( profile, floorType, level, structural ); Revit.ElementId fId = f.Id; m_shedElements.Add( fId ); // This param need to be set for any level above Level 1 for the floor to move to the correct level Revit.Parameter midFloorparam = f.get_Parameter( BuiltInParameter.FLOOR_HEIGHTABOVELEVEL_PARAM ); midFloorparam.Set( 0.0 ); return f.LevelId; } if( level.Name == "Level 1" ) { Floor f = doc.NewFloor( profile, floorType, level, structural ); Revit.ElementId fId = f.Id; m_shedElements.Add( fId ); return f.LevelId; } // if none of the types match return elemId; } catch( Exception e ) { throw e; } }
/// <summary> /// Create a floor for the selected set of walls. /// </summary> public void SimpleFloor() { Autodesk.Revit.Creation.Document doc = m_revitApp.ActiveUIDocument.Document.Create; Autodesk.Revit.Creation.Application applic = m_revitApp.Application.Create; // first filter out to only Wall elements Revit.ElementSet wallSet = Utils.Selection.FilterToCategory( m_revitApp.ActiveUIDocument.Selection.Elements, Revit.BuiltInCategory.OST_Walls, false, m_revitApp.ActiveUIDocument.Document ); if( wallSet.IsEmpty ) { MessageBox.Show( "No wall elements are currently selected" ); return; } // Get the wall profile needed for the floor CurveArray profile = applic.NewCurveArray(); foreach( Wall w in wallSet ) { Revit.LocationCurve curve = w.Location as Revit.LocationCurve; profile.Append( curve.Curve ); } // Obtain the required floor type FloorType floorType = null; try { FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( FloorType ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { FloorType f = element as FloorType; if( null == f ) { continue; } if( f.Name == "Generic - 12\"" ) { floorType = f; } } } catch( Exception e ) { throw e; } // Set the stuctural value bool structural = true; // Create the floor instance try { Floor f = doc.NewFloor( profile, floorType, doc.NewLevel( 0.0 ), structural ); } catch( Exception e ) { throw e; } }
/// <summary> /// Modify the width of a wall by changing the layer thickness. /// </summary> public void ModifyWallWidth() { Revit.Document doc = m_revitApp.ActiveUIDocument.Document; WallType outerWallType = null; FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( WallType ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { WallType wallType = element as WallType; if( wallType != null ) { // hardwired to affect a Generic - 8\" Wall Type if( wallType.Name == "Generic - 8\"" ) { outerWallType = wallType; } } } Boolean success = UpdateHostCompoudStructures( outerWallType ); }
/// <summary> /// Swap any selected door with a hardwired double door. /// </summary> private void SimpleSwap() { FamilySymbol doubleDoorSymbol = null; Autodesk.Revit.Creation.Document doc = m_revitApp.ActiveUIDocument.Document.Create; Revit.Document docu = m_revitApp.ActiveUIDocument.Document; Autodesk.Revit.UI.Selection.Selection sel = m_revitApp.ActiveUIDocument.Selection; Autodesk.Revit.Creation.Application applic = m_revitApp.Application.Create; // first filter out to only Door elements Revit.ElementSet doorSet = Utils.Selection.FilterToCategory( m_revitApp.ActiveUIDocument.Selection.Elements, Revit.BuiltInCategory.OST_Doors, false, m_revitApp.ActiveUIDocument.Document ); if( doorSet.IsEmpty ) { MessageBox.Show( "No door element is currently selected" ); return; } // Load the concerned door family FilteredElementCollector fec = new FilteredElementCollector( docu ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( Family ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { Family fam = element as Family; if( fam != null ) { if( fam.Name == "Double-Glass 1" ) { doubleDoorSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "72\" x 78\"" ); } } } string fileName = string.Empty; bool success = false; // Load the required family fileName = "../Data/Platform/Imperial/Library/Architectural/Doors/Double-Glass 1.rfa"; Family doubleDoorFamily = null; if( doubleDoorSymbol == null ) { success = m_revitApp.ActiveUIDocument.Document.LoadFamily( fileName, out doubleDoorFamily ); doubleDoorSymbol = Utils.FamilyUtil.GetFamilySymbol( doubleDoorFamily, "72\" x 78\"" ); } if( doubleDoorSymbol == null ) { MessageBox.Show( "Please load Double-Glass 1 into project" ); Utils.UserInput.LoadFamily( null, m_revitApp.ActiveUIDocument.Document ); } // Perform the swap. Revit.ElementSet elemSet = sel.Elements; System.Collections.IEnumerator iters = elemSet.GetEnumerator(); while( iters.MoveNext() ) { FamilyInstance famInst = (FamilyInstance) iters.Current; famInst.Symbol = doubleDoorSymbol; } }
/// <summary> /// /// </summary> public void ClassRoom() { Revit.Document doc = m_revitApp.ActiveUIDocument.Document; // get the symbols in the beginning itself , so that // if one is missing you can load it FamilySymbol columnSymbol = null; FamilySymbol chairSymbol = null; FamilySymbol deskSymbol = null; FamilySymbol chairMainSymbol = null; //FamilySymbol chairSym = null; FamilySymbol doorSymbol = null; Family columnfamily; Family deskfamily; Family doorfamily; FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter familiesAreWanted = new ElementClassFilter( typeof( Family ) ); fec.WherePasses( familiesAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { Family fam = element as Family; if( fam != null ) { if( fam.Name == "Rectangular Column" ) { columnSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "24\" x 24\"" ); } if( fam.Name == "Desk" ) { deskSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "60\" x 30\"" ); } if( fam.Name == "Single-Flush" ) { doorSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "36\" x 84\"" ); } if( fam.Name == "Chair-Tablet Arm" ) { chairSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "Chair-Tablet" ); } if( fam.Name == "Chair-Breuer" ) { chairMainSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "Chair-Breuer" ); } } } String familyNameToLoad = ""; // check for required families if( columnSymbol == null ) { MessageBox.Show( "Please load Rectangular Column 24\" x 24\" into project" ); String famName = Utils.UserInput.GetFamilyNameFromUser( null, ref familyNameToLoad ); m_revitApp.ActiveUIDocument.Document.LoadFamily( famName, out columnfamily ); if( columnfamily != null ) { columnSymbol = Utils.FamilyUtil.GetFamilySymbol( columnfamily, "24\" x 24\"" ); } } if( deskSymbol == null ) { MessageBox.Show( "Please load Desk 60\" x 30\" into project" ); String famName = Utils.UserInput.GetFamilyNameFromUser( null, ref familyNameToLoad ); m_revitApp.ActiveUIDocument.Document.LoadFamily( famName, out deskfamily ); if( deskfamily != null ) { deskSymbol = Utils.FamilyUtil.GetFamilySymbol( deskfamily, "36\" x 84\"" ); } } if( doorSymbol == null ) { MessageBox.Show( "Please load door Single Flush 36\" x 84\" into project" ); String famName = Utils.UserInput.GetFamilyNameFromUser( null, ref familyNameToLoad ); m_revitApp.ActiveUIDocument.Document.LoadFamily( famName, out doorfamily ); if( doorfamily != null ) { doorSymbol = Utils.FamilyUtil.GetFamilySymbol( doorfamily, "36\" x 84\"" ); } } IDictionary<String, String> libsPaths = m_revitApp.Application.GetLibraryPaths(); string pathName = string.Empty; foreach( KeyValuePair<String, String> libPath in libsPaths ) { pathName = libPath.Value; break; } string fileName = string.Empty; bool success = false; fileName = pathName + @"\Furniture\Chair-Tablet Arm.rfa"; //Boolean load = m_revitApp.ActiveUIDocument.Document.LoadFamilySymbol(fileName, "Chair-Tablet Arm", ref chairSym); Family chairFamily; // if not found in doc try to load automatically if( chairSymbol == null ) { success = m_revitApp.ActiveUIDocument.Document.LoadFamily( fileName, out chairFamily ); chairSymbol = Utils.FamilyUtil.GetFamilySymbol( chairFamily, "Chair-Tablet Arm" ); } // last ditch effort by trying to load manually if( chairSymbol == null ) { MessageBox.Show( "Please load Chair-Tablet Arm into project" ); Utils.UserInput.LoadFamily( null, m_revitApp.ActiveUIDocument.Document ); } fileName = pathName + @"\Furniture\Chair-Breuer.rfa"; Family chairMainFamily; // if not found in doc try to load automatically if( chairMainSymbol == null ) { success = m_revitApp.ActiveUIDocument.Document.LoadFamily( fileName, out chairMainFamily ); chairMainSymbol = Utils.FamilyUtil.GetFamilySymbol( chairMainFamily, "Chair-Breuer" ); } // last ditch effort by trying to load manually if( chairMainSymbol == null ) { MessageBox.Show( "Please load Chair-Breuer into project" ); Utils.UserInput.LoadFamily( null, m_revitApp.ActiveUIDocument.Document ); } // get the level on which we want to build Level level1 = null; FilteredElementCollector levelFec = new FilteredElementCollector( doc ); ElementClassFilter levelsAreWanted = new ElementClassFilter( typeof( Level ) ); levelFec.WherePasses( levelsAreWanted ); List<Element> levels = levelFec.ToElements() as List<Element>; foreach( Element element in levels ) { Level levelTemp = element as Level; if( levelTemp != null ) { if( levelTemp.Name == "Level 1" ) { level1 = levelTemp; break; } } } // draw 4 lines XYZ startPt1 = new XYZ( 0.0, 0.0, 0.0 ); XYZ endPt1 = new XYZ( 56.5, 0.0, 0.0 ); Line line1 = Line.CreateBound( startPt1, endPt1 ); XYZ startPt2 = endPt1; XYZ endPt2 = new XYZ( 56.5, 61.5, 0.0 ); Line line2 = Line.CreateBound( startPt2, endPt2 ); XYZ startPt3 = endPt2; XYZ endPt3 = new XYZ( 0.0, 61.5, 0.0 ); Line line3 = Line.CreateBound( startPt3, endPt3 ); XYZ startPt4 = endPt3; XYZ endPt4 = startPt1; Line line4 = Line.CreateBound( startPt4, endPt4 ); // get the wall types we want WallType curtainWallType = null; WallType outerWallType = null; FilteredElementCollector wallTypeFec = new FilteredElementCollector( doc ); ElementClassFilter wallTypesAreWanted = new ElementClassFilter( typeof( WallType ) ); wallTypeFec.WherePasses( wallTypesAreWanted ); List<Element> wallTypes = wallTypeFec.ToElements() as List<Element>; foreach( Element element in wallTypes ) { WallType wallType = element as WallType; if( wallType != null ) { if( wallType.Name == "Curtain Wall 1" ) { curtainWallType = wallType; } if( wallType.Name == "Generic - 6\" Masonry" ) { outerWallType = wallType; } } } // draw 4 walls Autodesk.Revit.DB.Document activeDoc = m_revitApp.ActiveUIDocument.Document; Wall wall1 = Wall.Create( activeDoc, line1, outerWallType.Id, level1.Id, 7.0, 0.0, false, false ); Wall wall2 = Wall.Create( activeDoc, line2, curtainWallType.Id, level1.Id, 7.0, 0.0, false, false ); Wall wall3 = Wall.Create( activeDoc, line3, curtainWallType.Id, level1.Id, 7.0, 0.0, false, false ); Wall wall4 = Wall.Create( activeDoc, line4, curtainWallType.Id, level1.Id, 7.0, 0.0, false, false ); FamilyInstance StructColumn1 = m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( startPt1, columnSymbol, wall1, level1, StructuralType.Column ); FamilyInstance StructColumn2 = m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( startPt2, columnSymbol, wall2, level1, StructuralType.Column ); FamilyInstance StructColumn3 = m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( startPt3, columnSymbol, wall3, level1, StructuralType.Column ); FamilyInstance StructColumn4 = m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( startPt4, columnSymbol, wall4, level1, StructuralType.Column ); int row = 5; int col = 8; double x = 5.0; double y = 11.0; double z = 0.0; XYZ refDirection = new XYZ( 1, 10, 0 ); // place all the chairs for( int i = 0; i < row; i++ ) { y = y + 8; for( int j = 0; j < col; j++ ) { x = x + 5; XYZ location = new XYZ( x, y, z ); FamilyInstance famInst = m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( location, chairSymbol, StructuralType.UnknownFraming ); // flip the chairs 180 degrees XYZ pt = location; XYZ dir = GeomUtils.kZAxis; Line zAxis = Line.CreateUnbound( pt, dir ); famInst.Location.Rotate( zAxis, GeomUtils.kRad180 ); } x = x - ( col * 5 ); } // place the desk XYZ deskPosition = new XYZ( 15.0, 8.0, 0.0 ); m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( deskPosition, deskSymbol, StructuralType.UnknownFraming ); // place the chair XYZ chairPosition = new XYZ( 18, 7.0, 0.0 ); m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( chairPosition, chairMainSymbol, StructuralType.UnknownFraming ); // place the door XYZ doorPosition = new XYZ( 46.0, 0.0, 0.0 ); m_revitApp.ActiveUIDocument.Document.Create.NewFamilyInstance( doorPosition, doorSymbol, wall1, StructuralType.Brace ); }
/// <summary> /// Creates a simple shed consisting of a door, window, a few floors and walls /// </summary> public void SimpleShed() { FamilySymbol doorSymbol = null; FamilySymbol windowSymbol = null; Family doorFamily = null; Family windowFamily = null; Autodesk.Revit.Creation.Document doc = m_revitApp.ActiveUIDocument.Document.Create; Revit.Document docu = m_revitApp.ActiveUIDocument.Document; Autodesk.Revit.Creation.Application applic = m_revitApp.Application.Create; //The levels for the floors and the fake roof Level floorLevel = null; Level midLevel = null; Revit.ElementSet wallSet = new ElementSet(); // Create a new CurveArray to provide the profile of the walls to the floor CurveArray curArray = applic.NewCurveArray(); // iterate through all available levels... FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( Level ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { Level sysLevel = element as Level; if( sysLevel != null ) { String name = sysLevel.Name; if( name == "Level 1" ) { floorLevel = sysLevel; } if( name == "Level 2" ) { midLevel = sysLevel; } } } // first create 4 walls // wall1 XYZ pt1 = new XYZ( 10.0, 10.0, 0.0 ); XYZ pt2 = new XYZ( 30.0, 10.0, 0.0 ); Line line = Line.CreateBound( pt1, pt2 ); Wall windowHost = Wall.Create( docu, line, floorLevel.Id, false ); curArray.Append( line ); wallSet.Insert( windowHost ); Revit.ElementId windowHostId = windowHost.Id; m_shedElements.Add( windowHostId ); // wall2 XYZ pt3 = new XYZ( 10.0, 10.0, 0.0 ); XYZ pt4 = new XYZ( 10.0, 30.0, 0.0 ); Line line1 = Line.CreateBound( pt3, pt4 ); Wall wall2 = Wall.Create( docu, line1, floorLevel.Id, false ); curArray.Append( line1 ); wallSet.Insert( wall2 ); Revit.ElementId wall2Id = wall2.Id; m_shedElements.Add( wall2Id ); // wall3 XYZ pt5 = new XYZ( 10.0, 30.0, 0.0 ); XYZ pt6 = new XYZ( 30.0, 30.0, 0.0 ); Line line2 = Line.CreateBound( pt5, pt6 ); Wall doorHost = Wall.Create( docu, line2, floorLevel.Id, false ); curArray.Append( line2 ); wallSet.Insert( doorHost ); Revit.ElementId doorHostId = doorHost.Id; m_shedElements.Add( doorHostId ); // wall4 XYZ pt7 = new XYZ( 30.0, 30.0, 0.0 ); XYZ pt8 = new XYZ( 30.0, 10.0, 0.0 ); Line line3 = Line.CreateBound( pt7, pt8 ); Wall wall4 = Wall.Create( docu, line3, floorLevel.Id, false ); curArray.Append( line3 ); wallSet.Insert( wall4 ); Revit.ElementId wall4Id = wall4.Id; m_shedElements.Add( wall4Id ); if( curArray != null ) { // add two floors to the walls created above Revit.ElementId floorId = SimpleFloor( curArray, floorLevel ); SimpleFloor( curArray, midLevel ); // set the top/bottom constraint and room bounding params for the walls // Note: The WALL_TOP/BOTTOM_IS_ATTACHED parameter's value when set, does not seem to stick. This needs // to be looked into as well. arj 7/25/06 // The WALL_TOP/BOTTOM_IS_ATTACHED parameters are Read Only and cannot be set. arj 01/17/07 foreach( Wall wall in wallSet ) { Revit.Parameter wallRoomBound = wall.get_Parameter( BuiltInParameter.WALL_ATTR_ROOM_BOUNDING ); wallRoomBound.Set( 1 ); Revit.Parameter wallBaseConstr = wall.get_Parameter( BuiltInParameter.WALL_BASE_CONSTRAINT ); wallBaseConstr.Set( floorId ); } } // set the location for elements such as doors, windows XYZ doorLocation = new XYZ( 20.0, 30.0, 0.0 ); XYZ windowLocation = new XYZ( 20.0, 10.0, 10.0 ); // check for required symbols FilteredElementCollector familyFec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter familiesAreWanted = new ElementClassFilter( typeof( Family ) ); familyFec.WherePasses( familiesAreWanted ); List<Element> families = familyFec.ToElements() as List<Element>; foreach( Element element in families ) { Family fam = element as Family; if( fam != null ) { if( fam.Name == "Single-Flush" ) { doorSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "36\" x 84\"" ); } if( fam.Name == "Fixed" ) { windowSymbol = Utils.FamilyUtil.GetFamilySymbol( fam, "24\" x 48\"" ); } } } // check for required symbols String familyNameToLoad = ""; if( doorSymbol == null ) { MessageBox.Show( "Please load Single-Flush 34\" x 84\" into project" ); String famName = Utils.UserInput.GetFamilyNameFromUser( null, ref familyNameToLoad ); m_revitApp.ActiveUIDocument.Document.LoadFamily( famName, out doorFamily ); if( doorFamily != null ) { doorSymbol = Utils.FamilyUtil.GetFamilySymbol( doorFamily, "36\" x 84\"" ); } } if( windowSymbol == null ) { MessageBox.Show( "Please load Fixed 24\" x 48\" into project" ); String famName = Utils.UserInput.GetFamilyNameFromUser( null, ref familyNameToLoad ); m_revitApp.ActiveUIDocument.Document.LoadFamily( famName, out windowFamily ); if( windowFamily != null ) { windowSymbol = Utils.FamilyUtil.GetFamilySymbol( windowFamily, "24\" x 48\"" ); } } // Create the door instance floorLevel.Elevation = 0.0; FamilyInstance doorInst = doc.NewFamilyInstance( doorLocation, doorSymbol, doorHost, floorLevel, StructuralType.Column ); Revit.ElementId doorInstId = doorInst.Id; m_shedElements.Add( doorInstId ); // Create the window instance floorLevel.Elevation = 0.0; FamilyInstance windowInst = doc.NewFamilyInstance( windowLocation, windowSymbol, windowHost, floorLevel, StructuralType.Column ); // The sill height needs to be set to 4.0 or less for the window to be visible in Level 1 view. Revit.Parameter sillHeightParam = windowInst.get_Parameter( BuiltInParameter.INSTANCE_SILL_HEIGHT_PARAM ); sillHeightParam.Set( 4.0 ); Revit.ElementId windowInstId = windowInst.Id; m_shedElements.Add( windowInstId ); }
private void ProcessElements( Document doc ) { FilteredElementCollector fec = new FilteredElementCollector( doc ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( Element ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { RawObjStats( element ); if( element != null ) { SymbolRefStats( element ); CategoryStats( element ); } } }
GetAvailableViewsToExport (Document doc) { ViewSet viewSet = new ViewSet(); // TBD: using a filter iterator will only give you the base class View, not derived classes // like View3D or ViewDrafting. /*ElementFilterIterator viewIter = m_revitApp.ActiveUIDocument.Document.GetElements(typeof(Autodesk.Revit.DB.View)); while (viewIter.MoveNext()) { Autodesk.Revit.DB.View tmpView = (Autodesk.Revit.DB.View)viewIter.Current; if (tmpView.CanBePrinted) viewSet.Insert((Autodesk.Revit.DB.View)viewIter.Current); }*/ FilteredElementCollector fec = new FilteredElementCollector(doc); ElementClassFilter elementsAreWanted = new ElementClassFilter(typeof(View)); fec.WherePasses(elementsAreWanted); List<Element> elements = fec.ToElements() as List<Element>; foreach (Element element in elements) { Autodesk.Revit.DB.View tmpView = element as Autodesk.Revit.DB.View; if ((tmpView != null) && tmpView.CanBePrinted) { viewSet.Insert(tmpView); } } return viewSet; }
// should be handled by the ModelUpdater class. But there are some // cases where the document modifications handled there do no catch // certain document interactions. Those should be registered here. /// <summary> /// Register some document updaters. Generally, document updaters /// </summary> /// <param name="application"></param> private static void RegisterAdditionalUpdaters(UIControlledApplication application) { var sunUpdater = new SunPathUpdater(application.ActiveAddInId); if (!UpdaterRegistry.IsUpdaterRegistered(sunUpdater.GetUpdaterId())) UpdaterRegistry.RegisterUpdater(sunUpdater); var sunFilter = new ElementClassFilter(typeof(SunAndShadowSettings)); var filterList = new List<ElementFilter> { sunFilter }; ElementFilter filter = new LogicalOrFilter(filterList); UpdaterRegistry.AddTrigger( sunUpdater.GetUpdaterId(), filter, Element.GetChangeTypeAny()); Updaters.Add(sunUpdater); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { try { UIApplication uiApp = commandData.Application; UIDocument uidoc = uiApp.ActiveUIDocument; Application app = uiApp.Application; Document doc = uidoc.Document; Stopwatch sw = Stopwatch.StartNew(); // f5 = f1 && f4 // = f1 && (f2 || f3) // = family instance and (door or window) #region Filters and collector definitions ElementClassFilter f1 = new ElementClassFilter( typeof( FamilyInstance ) ); ElementCategoryFilter f2 = new ElementCategoryFilter( BuiltInCategory.OST_Doors ); ElementCategoryFilter f3 = new ElementCategoryFilter( BuiltInCategory.OST_Windows ); LogicalOrFilter f4 = new LogicalOrFilter( f2, f3 ); LogicalAndFilter f5 = new LogicalAndFilter( f1, f4 ); FilteredElementCollector collector = new FilteredElementCollector( doc ); #endregion //#region Filtering with a class filter //List<Element> openingInstances = // collector.WherePasses(f5).ToElements() // as List<Element>; //#endregion //#region Filtering with an anonymous method //List<Element> openings = collector // .WherePasses(f4) // .ToElements() as List<Element>; //List<Element> openingInstances // = openings.FindAll( // e => e is FamilyInstance ); //#endregion #region Filtering with LINQ List<Element> openings = collector .WherePasses( f4 ) .ToElements() as List<Element>; List<Element> openingInstances = ( from instances in openings where instances is FamilyInstance select instances ).ToList<Element>(); #endregion int n = openingInstances.Count; sw.Stop(); Debug.WriteLine( string.Format( "Time to get {0} elements: {1}ms", n, sw.ElapsedMilliseconds ) ); return Result.Succeeded; } catch( Exception ex ) { message = ex.Message + ex.StackTrace; return Result.Failed; } }
/// <summary> /// Demonstrates the increase of floor to floor height by iterating over a set of available /// levels. /// </summary> public void SimpleLevelIteration() { // Clear all related elements if a shed has already been created to prevent overlapping elements. m_revitApp.ActiveUIDocument.Document.Delete( m_shedElements ); // Use the simple shed sample to demonstrate the increase in floor to floor height. SimpleShed(); DialogResult dlgRes = MessageBox.Show( "This will increase the floor to floor height of the Simple Shed by 10 Ft \n \t\t Hit Cancel to see original shed.", "Test Framework", MessageBoxButtons.OKCancel, MessageBoxIcon.Information ); if( dlgRes == System.Windows.Forms.DialogResult.OK ) { ArrayList levels = new ArrayList(); ArrayList elevations = new ArrayList(); Hashtable hash = new Hashtable(); FilteredElementCollector fec = new FilteredElementCollector( m_revitApp.ActiveUIDocument.Document ); ElementClassFilter elementsAreWanted = new ElementClassFilter( typeof( Level ) ); fec.WherePasses( elementsAreWanted ); List<Element> elements = fec.ToElements() as List<Element>; foreach( Element element in elements ) { Level systemLevel = element as Level; if( null != systemLevel ) { // collect all the levels levels.Add( systemLevel ); } } // Polulates a hashtable with the [key. value] pair represented as [Elevation, Level] // Also populate a list of elevations. for( Int32 i = 0; i < levels.Count; i++ ) { Level lev = (Level) levels[i]; if( !hash.ContainsKey( lev.Elevation ) && !hash.ContainsValue( lev ) ) { hash.Add( lev.Elevation, lev ); } elevations.Add( lev.Elevation ); } // Sort the elevations elevations.Sort(); Double elevation = (Double) elevations[0]; // Now that we have the elevations sorted, get the levels corresponding to them and bump // them up by a desired value. for( Int32 z = 1; z < elevations.Count; z++ ) { Double elev = (Double) elevations[z]; if( elev != 0.0 ) { Level level = (Level) hash[elev]; elevation = elevation + 20.0; level.Elevation = elevation; } } } }