/// <summary> /// Retrieve all supply air terminals from given document. /// Select all family instance elements of BuiltInCategory /// OST_DuctTerminal with system type equal to suppy air. /// </summary> public static FilteredElementCollector GetSupplyAirTerminals(Document doc) { FilteredElementCollector collector = new FilteredElementCollector(doc); collector.OfCategory(BuiltInCategory.OST_DuctTerminal); collector.OfClass(typeof(FamilyInstance)); //int n1 = collector.ToElements().Count; // 61 in sample model // ensure that system type equals supply air: // // in Revit 2009 and 2010 API, this did it: // //ParameterFilter parameterFilter = a.Filter.NewParameterFilter( // Bip.SystemType, CriteriaFilterType.Equal, ParameterValue.SupplyAir ); // in Revit 2011, create an ElementParameter filter. // Create filter by provider and evaluator: ParameterValueProvider provider = new ParameterValueProvider(new ElementId(Bip.SystemType)); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); string ruleString = ParameterValue.SupplyAir; FilterRule rule = new FilterStringRule(provider, evaluator, ruleString, false); ElementParameterFilter filter = new ElementParameterFilter(rule); collector.WherePasses(filter); //int n2 = collector.ToElements().Count; // 51 in sample model return(collector); }
/// <summary> /// ElementParameterFilter参数过滤器 Creates an ElementParameter filter to find rooms whose area is greater than specified value /// </summary> /// <remarks>提示: 参数过滤条件可能比其他的类型过滤条件要快,但是这要视条件而定。毕竟这是一个慢过,使用时请按照过滤标准的复杂程度而异。</remarks> public void ElementParameterFilter_FindRooms(Document Document) { // 以下5个步骤演示了要进行参数过滤的完整过程。 // provider ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(BuiltInParameter.ROOM_AREA)); // evaluator FilterNumericRuleEvaluator fnrv = new FilterNumericGreater(); // 过滤规则 : 参数“房间面积”的值“大于”“100 Square Foot”。(浮点数比较的容差为0.000001) FilterRule fRule = new FilterDoubleRule(pvp, fnrv, 100, 0.000001); // Create an ElementParameter filter ElementParameterFilter filter = new ElementParameterFilter(fRule); // Apply the filter to the elements in the active document FilteredElementCollector collector = new FilteredElementCollector(Document); IList <Element> rooms = collector.WherePasses(filter).ToElements(); // 反转过滤条件 // Find rooms whose area is less than or equal to 100: // Use inverted filter to match elements ElementParameterFilter lessOrEqualFilter = new ElementParameterFilter(fRule, true); collector = new FilteredElementCollector(Document); IList <Element> lessOrEqualFounds = collector.WherePasses(lessOrEqualFilter).ToElements(); }
private bool CreateFiltersIfMissing(Document doc) { if (curLODfilter != null && tarLODfilter != null) { return(false); } ElementId val = LODapp.GetLODparameter(doc, "Current_LOD").get_Id(); ElementId val2 = LODapp.GetLODparameter(doc, "Target_LOD").get_Id(); ParameterValueProvider val3 = new ParameterValueProvider(val); ParameterValueProvider val4 = new ParameterValueProvider(val2); FilterNumericRuleEvaluator val5 = new FilterNumericEquals(); ElementParameterFilter[] array = (ElementParameterFilter[])new ElementParameterFilter[VALID_CURRENT_LOD_VALUES.Length]; for (int i = 0; i < VALID_CURRENT_LOD_VALUES.Length; i++) { FilterIntegerRule val6 = new FilterIntegerRule(val3, val5, VALID_CURRENT_LOD_VALUES[i]); array[i] = new ElementParameterFilter(val6, true); } curLODfilter = new LogicalAndFilter((IList <ElementFilter>)array); ElementParameterFilter[] array2 = (ElementParameterFilter[])new ElementParameterFilter[VALID_TARGET_LOD_VALUES.Length]; for (int j = 0; j < VALID_TARGET_LOD_VALUES.Length; j++) { FilterIntegerRule val7 = new FilterIntegerRule(val4, val5, VALID_TARGET_LOD_VALUES[j]); array2[j] = new ElementParameterFilter(val7, true); } tarLODfilter = new LogicalAndFilter((IList <ElementFilter>)array2); return(true); }
protected internal virtual void initializeOutputParameter(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CallableElement callableElement) { ExpressionManager expressionManager = context.ExpressionManager; IList <CamundaOut> outputs = getOutputs(element); foreach (CamundaOut output in outputs) { // create new parameter CallableElementParameter parameter = new CallableElementParameter(); callableElement.addOutput(parameter); // all variables string variables = output.CamundaVariables; if ("all".Equals(variables)) { parameter.AllVariables = true; continue; } // source/sourceExpression string source = output.CamundaSource; if (string.ReferenceEquals(source, null) || source.Length == 0) { source = output.CamundaSourceExpression; } ParameterValueProvider sourceValueProvider = createParameterValueProvider(source, expressionManager); parameter.SourceValueProvider = sourceValueProvider; // target string target = output.CamundaTarget; parameter.Target = target; } }
public Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Document document = commandData.Application.ActiveUIDocument.Document; UIDocument uidoc = commandData.Application.ActiveUIDocument; ICollection <ElementId> ids = uidoc.Selection.GetElementIds(); string prompt = ""; BuiltInParameter volParam = BuiltInParameter.HOST_VOLUME_COMPUTED; // provider ParameterValueProvider pvp = new ParameterValueProvider(new ElementId((int)volParam)); // evaluator FilterNumericRuleEvaluator fnrv = new FilterNumericGreater(); // 篩選面體積大於500立方呎的元件 double ruleValue = 500f; // rule 規則 FilterRule fRule = new FilterDoubleRule(pvp, fnrv, ruleValue, 1E-6); // Create an ElementParameter filter 創建ElementParameter篩選器 ElementParameterFilter filter = new ElementParameterFilter(fRule); // Apply the filter to the elements in the active document 使用這個篩選器到作用文件檔案中的元件 FilteredElementCollector collector = new FilteredElementCollector(document); IList <Element> elems = collector.WherePasses(filter).ToElements(); prompt += "篩選後的元件數量:" + elems.Count.ToString() + "\n"; ElementCategoryFilter filterWall = new ElementCategoryFilter(BuiltInCategory.OST_Walls); IList <Element> walls = collector.WherePasses(filter).WherePasses(filterWall).ToElements(); prompt += "篩選後的牆數量:" + walls.Count.ToString() + "\n"; TaskDialog.Show("篩選", prompt); return(Autodesk.Revit.UI.Result.Succeeded); }
public IList <Element> GetElementValueDouble(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue) { IList <Element> vResult = new List <Element>(); foreach (var vCategoryId in valCategoryElementId) { BuiltInCategory vBuiltInCategory = (BuiltInCategory)vCategoryId.IntegerValue; ParameterValueProvider vPovider = new ParameterValueProvider(valRevitParameter.ElementId); string vRulestring = valValue; FilteredElementCollector vCollector = new FilteredElementCollector(_Doc); vCollector.OfCategory(vBuiltInCategory); LibNumeric insLibNumeric = new LibNumeric(); double ruleValDb = 0.0; if (insLibNumeric.IsDouble(valValue)) { Double vNum = 0; Double.TryParse(valValue, out vNum); ruleValDb = vNum; } ParameterValueProvider pvp = new ParameterValueProvider(valRevitParameter.ElementId); FilterNumericEquals fnrv = new FilterNumericEquals(); var vFilterDoubleRule = new FilterDoubleRule(pvp, fnrv, ruleValDb, 10e-10); var epf = new ElementParameterFilter(vFilterDoubleRule); vCollector.WherePasses(epf); IList <Element> vElements = vCollector.ToElements(); if (vElements != null) { if (vElements.Count > 0) { vResult = vElements.Concat(vElements).ToList(); } } } return(vResult); }
/// <summary> /// Return the first wall found that /// uses the given wall type. /// </summary> static Wall GetFirstWallUsingType( Document doc, WallType wallType) { // built-in parameter storing this // wall's wall type element id: BuiltInParameter bip = BuiltInParameter.ELEM_TYPE_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId(bip)); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); FilterRule rule = new FilterElementIdRule( provider, evaluator, wallType.Id); ElementParameterFilter filter = new ElementParameterFilter(rule); FilteredElementCollector collector = new FilteredElementCollector(doc) .OfClass(typeof(Wall)) .WherePasses(filter); return(collector.FirstElement() as Wall); }
public static FilteredElementCollector collectorFromTreeView(Document doc, ObservableCollection <Node> nodes) { IList <ElementFilter> familyAndTypeFilters = new List <ElementFilter>(); foreach (var category in nodes) { foreach (var family in category.Children) { foreach (var familyType in family.Children) { if (familyType.IsChecked == true) { ParameterValueProvider fvp = new ParameterValueProvider(new ElementId(BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM)); FilterStringRuleEvaluator fsre = new FilterStringEquals(); string ruleString = String.Format("{0}: {1}", family.Text, familyType.Text); FilterRule fRule = new FilterStringRule(fvp, fsre, ruleString, true); ElementParameterFilter filter = new ElementParameterFilter(fRule); familyAndTypeFilters.Add(filter); } } } } LogicalOrFilter familyAndTypeFilter = new LogicalOrFilter(familyAndTypeFilters); FilteredElementCollector collector = new FilteredElementCollector(doc).WherePasses(familyAndTypeFilter); return(collector); }
public static FilteredElementCollector GetElementsByShareParamValue( Document doc, BuiltInCategory bic, string sParaName, string sValue) { SharedParameterElement para = (from p in new FilteredElementCollector(doc) .OfClass(typeof(SharedParameterElement)) .Cast <SharedParameterElement>() where p.Name.Equals(sParaName) select p).First(); ParameterValueProvider provider = new ParameterValueProvider(para.Id); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); string sType = sValue; FilterRule rule = new FilterStringRule( provider, evaluator, sType, false); ElementParameterFilter filter = new ElementParameterFilter(rule); FilteredElementCollector collector = new FilteredElementCollector(doc) .OfCategory(bic) .WherePasses(filter); return(collector); }
public static FilteredElementCollector GetElementsByShareParamValue(Document doc, BuiltInCategory bic, string sParaName, double dValue) { SharedParameterElement para = (from p in new FilteredElementCollector(doc) .OfClass(typeof(SharedParameterElement)) .Cast <SharedParameterElement>() where p.Name.Equals(sParaName) select p).First(); ParameterValueProvider provider = new ParameterValueProvider(para.Id); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); double sLength_feet = UnitUtils.Convert( dValue, DisplayUnitType.DUT_METERS, DisplayUnitType.DUT_DECIMAL_FEET); double epsilon = 0.0001; FilterRule rule = new FilterDoubleRule( provider, evaluator, sLength_feet, epsilon); ElementParameterFilter filter = new ElementParameterFilter(rule); FilteredElementCollector collector = new FilteredElementCollector(doc) .OfCategory(bic) .WherePasses(filter); return(collector); }
//Check to see if a Sheet Number already exists in the project and create it if not private ViewSheet CheckSheet(string _sheetNumber, ElementId _vpTypeId) { try { ViewSheet sheet = null; ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(BuiltInParameter.SHEET_NUMBER)); FilterStringRuleEvaluator fsr = new FilterStringEquals(); FilterRule fRule = new FilterStringRule(pvp, fsr, _sheetNumber, true); ElementParameterFilter filter = new ElementParameterFilter(fRule); if (new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Sheets).WherePasses(filter).FirstOrDefault() is ViewSheet vs) { sheet = vs; } else { sheet = ViewSheet.Create(doc, _vpTypeId); sheet.Name = "DO NOT PRINT"; sheet.SheetNumber = _sheetNumber; //Set additional View Parameters based on Firm standards and Project Broswer Sorting templates //sheet.LookupParameter("Sheet Sort").Set("PLANS"); //Set the Appears In Sheet List to False so duplicate sheets do not appear in Sheet Index Schedule sheet.get_Parameter(BuiltInParameter.SHEET_SCHEDULED).Set(0); } return(sheet); } catch { return(null); } }
/// <summary> /// Optional - example of parameter filter. /// Find walls whose length is longer than a certain length. e.g., 60 feet /// wall.parameter(length) > 60 feet /// This could get more complex than looping through in terms of writing a code. /// See page 87 of Developer guide. /// </summary> public IList <Element> FindLongWalls() { // Constant for this function. const double kWallLength = 60.0; // 60 feet. hard coding for simplicity. // First, narrow down to the elements of the given type and category var collector = new FilteredElementCollector(_doc).OfClass(typeof(Wall)); // Define a filter by parameter // 1st arg - value provider BuiltInParameter lengthParam = BuiltInParameter.CURVE_ELEM_LENGTH; int iLengthParam = (int)lengthParam; var paramValueProvider = new ParameterValueProvider(new ElementId(iLengthParam)); // 2nd - evaluator FilterNumericGreater evaluator = new FilterNumericGreater(); // 3rd - rule value double ruleVal = kWallLength; // 4th - epsilon const double eps = 1E-06; // Define a rule var filterRule = new FilterDoubleRule(paramValueProvider, evaluator, ruleVal, eps); // Create a new filter var paramFilter = new ElementParameterFilter(filterRule); // Go through the filter IList <Element> elems = collector.WherePasses(paramFilter).ToElements(); return(elems); }
public ViewSheet ReferenceSheet(Document doc, View view) { ViewSheet viewhseetrf = null; DateTime start = DateTime.Now; FilterableValueProvider provider = new ParameterValueProvider(new ElementId(BuiltInParameter.VIEW_SHEET_VIEWPORT_INFO)); FilterRule rule = new FilterStringRule(provider, new FilterStringGreater(), string.Empty, false); ElementParameterFilter epf = new ElementParameterFilter(rule, false); FilteredElementCollector viewCol = new FilteredElementCollector(doc).WherePasses(epf); viewCol.OfClass(typeof(ViewSheet)); StringBuilder sb = new StringBuilder(); foreach (ViewSheet v in viewCol) { try { ISet <ElementId> col = v.GetAllPlacedViews(); foreach (var fg in col) { if (fg == view.Id) { sb.AppendLine("View: " + v.Name); viewhseetrf = v; } } } catch { } } return(viewhseetrf); }
/// <summary> /// Возвращает список всех чистых помещений /// </summary> public static List <Room> GetAllCleanRooms(Document doc) { FilteredElementCollector collector = new FilteredElementCollector(doc); RoomFilter roomFilter = new RoomFilter(); collector.WherePasses(roomFilter); // Настройка фильтра для комнат заданным параметром "BL_Класс чистоты", // равным "A", "B", "C" или "D" Guid spGuid = new Guid("02f7e9d4-f055-479e-a36f-5b8e098d40f5"); Room fRoom = collector.FirstElement() as Room; Parameter testSharedParam = fRoom.get_Parameter(spGuid); ElementId sharedParamId = testSharedParam.Id; ParameterValueProvider provider = new ParameterValueProvider(sharedParamId); FilterStringRuleEvaluator fsreEqual = new FilterStringEquals(); string testStrCNC = "CNC"; string testVoidStrCNC = ""; FilterRule fCNCRule = new FilterStringRule(provider, fsreEqual, testStrCNC, false); FilterRule fVoidStrRule = new FilterStringRule(provider, fsreEqual, testVoidStrCNC, false); ElementParameterFilter paramNoCNCFilter = new ElementParameterFilter(fCNCRule, true); ElementParameterFilter paramNoVoidFilter = new ElementParameterFilter(fVoidStrRule, true); collector.WherePasses(paramNoVoidFilter).WherePasses(paramNoCNCFilter); List <Room> cleanRooms = (from e in collector.ToElements() where e is Room select e as Room).ToList <Room>(); return(cleanRooms); }
public static ICollection <ElementId> GetTypeBICInPhase(Document doc, Type thisType, BuiltInCategory bic, Phase phase) { // http://spiderinnet.typepad.com/blog/2011/07/ // elementparameterfilter-using-filterelementidrule-to-filter-element-parameters-in-c.html // // • An ElementParameterFilter needs a filter rule, the FilterElementIdRule in this case. // • The FilterElementIdRule needs a parameter value provider (ParameterValueProvider) and // a filter rule evaluator (FilterStringRuleEvaluator), specifically the FilterNumericEquals here. // • Do not feel surprised that the FilterNumericEquals evaluator also works with the FilterElementIdRule // as the ElementId is effectively nothing more than an integer value. // • The ParameterValueProvider needs an argument of parameter, as the phase created parameter // BuiltInParameter.PHASE_CREATED in this case. // • The parameter is represented by an ElementId, which is the numeric value of the specified BuiltInParameter. // • A fast filter, ElementClassFilter, represented by its shortcut method (OfClass), is also used to // narrow down the FilteredElementCollector first. It not only speeds up the search but also makes sure only walls are returned. ParameterValueProvider provider = new ParameterValueProvider(new ElementId((int)BuiltInParameter.PHASE_CREATED)); FilterElementIdRule rule1 = new FilterElementIdRule(provider, new FilterNumericEquals(), phase.Id); ElementParameterFilter filter1 = new ElementParameterFilter(rule1); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.OfClass(thisType); collector.OfCategory(bic); collector.WherePasses(filter1); return(collector.ToElementIds()); }
/// <summary> /// Return the first wall type with the given name. /// </summary> static WallType GetFirstWallTypeNamed( Document doc, string name) { // built-in parameter storing this // wall type's name: BuiltInParameter bip = BuiltInParameter.SYMBOL_NAME_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId(bip)); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule( provider, evaluator, name, false); ElementParameterFilter filter = new ElementParameterFilter(rule); FilteredElementCollector collector = new FilteredElementCollector(doc) .OfClass(typeof(WallType)) .WherePasses(filter); return(collector.FirstElement() as WallType); }
/// <summary> /// Return the viewport on the given /// sheet displaying the given view. /// </summary> Element GetViewport(ViewSheet sheet, View view) { Document doc = sheet.Document; // filter for view name: BuiltInParameter bip = BuiltInParameter.VIEW_NAME; ParameterValueProvider provider = new ParameterValueProvider( new ElementId(bip)); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); //FilterRule rule = new FilterStringRule( // 2021 // provider, evaluator, view.Name, true ); FilterRule rule = new FilterStringRule( // 2022 provider, evaluator, view.Name); ElementParameterFilter name_filter = new ElementParameterFilter(rule); BuiltInCategory bic = BuiltInCategory.OST_Viewports; // retrieve the specific named viewport: //Element viewport // = new FilteredElementCollector( doc ) // .OfCategory( bic ) // .WherePasses( name_filter ) // .FirstElement(); //return viewport; // unfortunately, there are not just one, // but two candidate elements. apparently, // we can distibuish them using the // owner view id property: List <Element> viewports = new List <Element>( new FilteredElementCollector(doc) .OfCategory(bic) .WherePasses(name_filter) .ToElements()); Debug.Assert(viewports[0].OwnerViewId.Equals(ElementId.InvalidElementId), "expected the first viewport to have an invalid owner view id"); Debug.Assert(!viewports[1].OwnerViewId.Equals(ElementId.InvalidElementId), "expected the second viewport to have a valid owner view id"); int i = 1; return(viewports[i]); }
private void DocumentOpenedAction(object sender, DocumentOpenedEventArgs even) { settings = ExtensibleStorage.GetTooltipInfo(even.Document.ProjectInformation); this.mysql = new MysqlUtil(settings); this.sqlite = new SQLiteHelper(settings); m_previousDocPathName = even.Document.PathName; current_doc = even.Document; //过滤测点待使用 //打开文档就过滤一次 keyNameToElementMap = new Dictionary <string, Element>(); BuiltInParameter testParam = BuiltInParameter.ALL_MODEL_TYPE_NAME; ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(testParam)); FilterStringEquals eq = new FilterStringEquals(); FilterRule rule = new FilterStringRule(pvp, eq, Res.String_ParameterSurveyType, false); ElementParameterFilter paramFilter = new ElementParameterFilter(rule); Document document = current_doc; FilteredElementCollector elementCollector = new FilteredElementCollector(document).OfClass(typeof(FamilyInstance)); IList <Element> elems = elementCollector.WherePasses(paramFilter).ToElements(); foreach (var elem in elems) { string param_value = string.Empty; Parameter param = elem.get_Parameter(Res.String_ParameterName); if (null != param && param.StorageType == StorageType.String) { param_value = param.AsString(); if (!string.IsNullOrWhiteSpace(param_value)) { keyNameToElementMap.Add(param_value, elem); } } } //准备Material IEnumerable <Material> allMaterial = new FilteredElementCollector(even.Document).OfClass(typeof(Material)).Cast <Material>(); foreach (Material elem in allMaterial) { if (elem.Name.Equals(Res.String_Color_Redline)) { color_red = elem; } if (elem.Name.Equals(Res.String_Color_Gray)) { color_gray = elem; } if (elem.Name.Equals(Res.String_Color_Blue)) { color_blue = elem; } if (color_gray != null && color_red != null && color_blue != null) { this.ColorMaterialIsReady = true; break; } } }
public static FilteredElementCollector WhereTypeIdEqualsTo(this FilteredElementCollector collector, ElementId value) { using (var provider = new ParameterValueProvider(new ElementId(BuiltInParameter.ELEM_TYPE_PARAM))) using (var evaluator = new FilterNumericEquals()) using (var rule = new FilterElementIdRule(provider, evaluator, value)) using (var filter = new ElementParameterFilter(rule)) return(collector.WherePasses(filter)); }
public static FilteredElementCollector WhereParameterEqualsTo(this FilteredElementCollector collector, BuiltInParameter paramId, string value, bool caseSensitive = true) { using (var provider = new ParameterValueProvider(new ElementId(paramId))) using (var evaluator = new FilterStringEquals()) using (var rule = new FilterStringRule(provider, evaluator, value, caseSensitive)) using (var filter = new ElementParameterFilter(rule)) return(collector.WherePasses(filter)); }
public static ElementParameterFilter ParameterValueFilter(string valueQualifier, BuiltInParameter parameterName) { BuiltInParameter testParam = parameterName; ParameterValueProvider pvp = new ParameterValueProvider(new ElementId((int)testParam)); FilterStringRuleEvaluator str = new FilterStringEquals(); FilterStringRule paramFr = new FilterStringRule(pvp, str, valueQualifier, false); ElementParameterFilter epf = new ElementParameterFilter(paramFr); return(epf); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { // Get application and document objects UIApplication uiApp = commandData.Application; Document doc = uiApp.ActiveUIDocument.Document; UIDocument uidoc = uiApp.ActiveUIDocument; try { using (Transaction trans = new Transaction(doc, "UpperCase Views on Sheets.")) { // Delete all unnamed Reference Planes in the project // Create Filter to check for Name BuiltInParameter bip = BuiltInParameter.DATUM_TEXT; ParameterValueProvider provider = new ParameterValueProvider(new ElementId(bip)); FilterStringEquals evaluator = new FilterStringEquals(); FilterStringRule rule = new FilterStringRule(provider, evaluator, "", false); ElementParameterFilter filter = new ElementParameterFilter(rule); ICollection<ElementId> refPlanes = new FilteredElementCollector(doc) .OfClass(typeof(ReferencePlane)) .WherePasses(filter) .ToElementIds(); int count = refPlanes.Count; try { trans.Start(); doc.Delete(refPlanes); trans.Commit(); } catch (Exception x) { message = x.Message; return Result.Failed; } TaskDialog.Show("Delete Reference Planes", "You have successfully delete " + count.ToString() + " unnamed reference planes!"); return Result.Succeeded; } } // Catch any Exceptions and display them. catch (Autodesk.Revit.Exceptions.OperationCanceledException) { return Result.Cancelled; } catch (Exception x) { message = x.Message; return Result.Failed; } }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { // Get application and document objects UIApplication uiApp = commandData.Application; Document doc = uiApp.ActiveUIDocument.Document; UIDocument uidoc = uiApp.ActiveUIDocument; try { using (Transaction trans = new Transaction(doc, "UpperCase Views on Sheets.")) { // Delete all unnamed Reference Planes in the project // Create Filter to check for Name BuiltInParameter bip = BuiltInParameter.DATUM_TEXT; ParameterValueProvider provider = new ParameterValueProvider(new ElementId(bip)); FilterStringEquals evaluator = new FilterStringEquals(); FilterStringRule rule = new FilterStringRule(provider, evaluator, "", false); ElementParameterFilter filter = new ElementParameterFilter(rule); ICollection <ElementId> refPlanes = new FilteredElementCollector(doc) .OfClass(typeof(ReferencePlane)) .WherePasses(filter) .ToElementIds(); int count = refPlanes.Count; try { trans.Start(); doc.Delete(refPlanes); trans.Commit(); } catch (Exception x) { message = x.Message; return(Result.Failed); } TaskDialog.Show("Delete Reference Planes", "You have successfully delete " + count.ToString() + " unnamed reference planes!"); return(Result.Succeeded); } } // Catch any Exceptions and display them. catch (Autodesk.Revit.Exceptions.OperationCanceledException) { return(Result.Cancelled); } catch (Exception x) { message = x.Message; return(Result.Failed); } }
/// <summary> /// Retrieve all circuit elements in current active document, /// which we identify as all family instance or electrical system /// elements with a non-empty RBS_ELEC_CIRCUIT_NUMBER or "Circuit Number" /// parameter. /// </summary> public static IList <Element> GetCircuitElements(Document doc) { // // prepend as many 'fast' filters as possible, because parameter access is 'slow': // ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); ElementClassFilter f2 = new ElementClassFilter(typeof(ElectricalSystem)); LogicalOrFilter f3 = new LogicalOrFilter(f1, f2); FilteredElementCollector collector = new FilteredElementCollector(doc).WherePasses(f3); BuiltInParameter bip = BuiltInParameter.RBS_ELEC_CIRCUIT_NUMBER; #if DEBUG int n1 = collector.ToElements().Count; List <Element> a = new List <Element>(); foreach (Element e in collector) { Parameter p = e.get_Parameter(BuiltInParameter.RBS_ELEC_CIRCUIT_NUMBER); if (null != p && 0 < p.AsString().Length) { a.Add(e); } } int n2 = a.Count; Debug.Assert(n1 > n2, "expected filter to eliminate something"); List <Element> b = ( from e in collector.ToElements() where (null != e.get_Parameter(bip)) && (0 < e.get_Parameter(bip).AsString().Length) select e).ToList <Element>(); int n3 = b.Count; Debug.Assert(n2 == n3, "expected to reproduce same result"); #endif // DEBUG // // this is unclear ... negating the rule that says the parameter // exists and is empty could mean that elements pass if the parameter // is non-empty, but also if the parameter does not exist ... // so maybe returning the collection b instead of c would be a safer bet? // ParameterValueProvider provider = new ParameterValueProvider(new ElementId(bip)); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule(provider, evaluator, string.Empty, false); ElementParameterFilter filter = new ElementParameterFilter(rule, true); collector.WherePasses(filter); IList <Element> c = collector.ToElements(); int n4 = c.Count; Debug.Assert(n2 == n4, "expected to reproduce same result"); return(c); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIDocument uidoc = commandData.Application.ActiveUIDocument; try { int roomNum = 1; while (true) { Reference selRef = uidoc.Selection.PickObject(ObjectType.Element, new MySelectionFilter(), "Pick a room 2"); Room room = (Room)uidoc.Document.GetElement(selRef.ElementId); FilteredElementCollector collector = new FilteredElementCollector(uidoc.Document); collector.WherePasses(new RoomFilter()); ParameterValueProvider provider = new ParameterValueProvider(new ElementId(BuiltInParameter.ROOM_NUMBER)); FilterStringEquals evaluator = new FilterStringEquals(); FilterStringRule rule = new FilterStringRule(provider, evaluator, roomNum.ToString(), false); ElementParameterFilter filter = new ElementParameterFilter(rule); collector.WherePasses(filter); IList <Element> rooms = collector.ToElements(); if (rooms.Count > 0) { ((Room)(rooms[0])).Number = room.Number; } room.Number = roomNum.ToString(); uidoc.Document.Regenerate(); roomNum++; } } catch (Autodesk.Revit.Exceptions.OperationCanceledException) { } return(Result.Succeeded); }
/// <summary> /// Returns the priority which is defined in the given process definition. /// The priority value is identified with the given propertyKey. /// Returns null if the process definition is null or no priority was defined. /// </summary> /// <param name="processDefinition"> the process definition that should contains the priority </param> /// <param name="propertyKey"> the key which identifies the property </param> /// <param name="execution"> the current execution </param> /// <param name="errorMsgHead"> the error message header which is used if the evaluation fails </param> /// <returns> the priority defined in the given process </returns> protected internal virtual long?getProcessDefinedPriority(ProcessDefinitionImpl processDefinition, string propertyKey, ExecutionEntity execution, string errorMsgHead) { if (processDefinition != null) { ParameterValueProvider priorityProvider = (ParameterValueProvider)processDefinition.getProperty(propertyKey); if (priorityProvider != null) { return(evaluateValueProvider(priorityProvider, execution, errorMsgHead)); } } return(null); }
/** param name="level" the level for which the stairs should be retrieved for. * The list always consists of two elements. * The first list contains the list of stairs, that start on this level. * The second list contains the list of stairs, that end on this level. * * returns a List of all stairs that start or end at the current level. */ public List <KeyValuePair <string, List <Stairs> > > GetAllStairsFromLevel(UIDocument currentDocument, List <Stairs> allStairs, Level currentLevel) { var filteredStairs = new List <KeyValuePair <string, List <Stairs> > >(); var baseStairsOnLevel = new List <Stairs>(); var topStairsOnLevel = new List <Stairs>(); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); BuiltInParameter baseLevelParameter = BuiltInParameter.STAIRS_BASE_LEVEL_PARAM; ParameterValueProvider baseLevelProvider = new ParameterValueProvider(new ElementId(baseLevelParameter)); FilterRule baseLevelRule = new FilterElementIdRule(baseLevelProvider, evaluator, currentLevel.Id); ElementParameterFilter baseLevelFilter = new ElementParameterFilter(baseLevelRule); FilteredElementCollector baseStairsCollector = new FilteredElementCollector(currentDocument.Document).WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_Stairs); ICollection <ElementId> baseStairIds = baseStairsCollector.WherePasses(baseLevelFilter).ToElementIds(); foreach (ElementId currentBaseStairsId in baseStairIds) { if (Stairs.IsByComponent(currentDocument.Document, currentBaseStairsId)) { Stairs currentBaseStairs = currentDocument.Document.GetElement(currentBaseStairsId) as Stairs; if (!StairsListContainsElement(baseStairsOnLevel, currentBaseStairs) && !StairsListContainsElement(topStairsOnLevel, currentBaseStairs)) { baseStairsOnLevel.Add(currentBaseStairs); } } } BuiltInParameter topLevelParameter = BuiltInParameter.STAIRS_TOP_LEVEL_PARAM; ParameterValueProvider topLevelProvider = new ParameterValueProvider(new ElementId(topLevelParameter)); FilterRule topLevelRule = new FilterElementIdRule(topLevelProvider, evaluator, currentLevel.Id); ElementParameterFilter topLevelFilter = new ElementParameterFilter(topLevelRule); FilteredElementCollector topStairsCollector = new FilteredElementCollector(currentDocument.Document).WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_Stairs); ICollection <ElementId> topStairsIds = topStairsCollector.WherePasses(topLevelFilter).ToElementIds(); foreach (ElementId currentTopStairsId in topStairsIds) { if (Stairs.IsByComponent(currentDocument.Document, currentTopStairsId)) { Stairs currentTopStairs = currentDocument.Document.GetElement(currentTopStairsId) as Stairs; if (!StairsListContainsElement(baseStairsOnLevel, currentTopStairs) && !StairsListContainsElement(topStairsOnLevel, currentTopStairs)) { topStairsOnLevel.Add(currentTopStairs); } } } filteredStairs.Add(new KeyValuePair <string, List <Stairs> >(BASE_LEVEL_KEY, baseStairsOnLevel)); filteredStairs.Add(new KeyValuePair <string, List <Stairs> >(TOP_LEVEL_KEY, topStairsOnLevel)); return(filteredStairs); }
//returns a list of elements that have the same value for a specific parameter public static List <Element> GetElementsWithTheSameParameterValue(BuiltInParameter parameter, string value) { List <Element> elements = new List <Element>(); ParameterValueProvider provider = new ParameterValueProvider(new ElementId((int)parameter)); FilterStringRule rule1 = new FilterStringRule(provider, new FilterStringEquals(), value, false); ElementParameterFilter filter1 = new ElementParameterFilter(rule1, false); return ((new FilteredElementCollector(doc)) .WherePasses(filter1) .ToElements() as List <Element>); }
/// <summary> /// Parses a output parameter and adds it to the <seealso cref="IoMapping"/>. /// </summary> /// <param name="outputParameterElement"> the output parameter element </param> /// <param name="ioMapping"> the mapping to add the element </param> /// <exception cref="BpmnParseException"> if the output parameter element is malformed </exception> public static void parseOutputParameterElement(Element outputParameterElement, IoMapping ioMapping) { string nameAttribute = outputParameterElement.attribute("name"); if (string.ReferenceEquals(nameAttribute, null) || nameAttribute.Length == 0) { throw new BpmnParseException("Missing attribute 'name' for outputParameter", outputParameterElement); } ParameterValueProvider valueProvider = parseNestedParamValueProvider(outputParameterElement); // add parameter ioMapping.addOutputParameter(new OutputParameter(nameAttribute, valueProvider)); }
protected internal virtual void initializeInputParameter(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context, CallableElement callableElement) { ExpressionManager expressionManager = context.ExpressionManager; IList <CamundaIn> inputs = getInputs(element); foreach (CamundaIn input in inputs) { // businessKey string businessKey = input.CamundaBusinessKey; if (!string.ReferenceEquals(businessKey, null) && businessKey.Length > 0) { ParameterValueProvider businessKeyValueProvider = createParameterValueProvider(businessKey, expressionManager); callableElement.BusinessKeyValueProvider = businessKeyValueProvider; } else { // create new parameter CallableElementParameter parameter = new CallableElementParameter(); callableElement.addInput(parameter); if (input.CamundaLocal) { parameter.ReadLocal = true; } // all variables string variables = input.CamundaVariables; if ("all".Equals(variables)) { parameter.AllVariables = true; continue; } // source/sourceExpression string source = input.CamundaSource; if (string.ReferenceEquals(source, null) || source.Length == 0) { source = input.CamundaSourceExpression; } ParameterValueProvider sourceValueProvider = createParameterValueProvider(source, expressionManager); parameter.SourceValueProvider = sourceValueProvider; // target string target = input.CamundaTarget; parameter.Target = target; } } }
/// <summary> /// Generic Parameter value filter. An attempt to write a generic method, /// that returns an element filter consumed by FilteredElementCollector. /// </summary> /// <typeparam name="T1">Type of the parameter VALUE to filter by.</typeparam> /// <typeparam name="T2">Type of the PARAMETER to filter.</typeparam> /// <param name="value">Currently: string, bool.</param> /// <param name="parameterId">Currently: Guid, BuiltInCategory.</param> /// <returns>ElementParameterFilter consumed by FilteredElementCollector.</returns> public static ElementParameterFilter ParameterValueGenericFilter <T1, T2>(Document doc, T1 value, T2 parameterId) { //Initialize ParameterValueProvider ParameterValueProvider pvp = null; switch (parameterId) { case BuiltInParameter bip: pvp = new ParameterValueProvider(new ElementId((int)bip)); break; case Guid guid: SharedParameterElement spe = SharedParameterElement.Lookup(doc, guid); pvp = new ParameterValueProvider(spe.Id); break; default: throw new NotImplementedException("ParameterValueGenericFilter: T2 (parameter) type not implemented!"); } //Branch off to value types switch (value) { case string str: FilterStringRuleEvaluator fsrE = new FilterStringEquals(); FilterStringRule fsr = new FilterStringRule(pvp, fsrE, str, false); return(new ElementParameterFilter(fsr)); case bool bol: int _value; if (bol == true) { _value = 1; } else { _value = 0; } FilterNumericRuleEvaluator fnrE = new FilterNumericEquals(); FilterIntegerRule fir = new FilterIntegerRule(pvp, fnrE, _value); return(new ElementParameterFilter(fir)); default: throw new NotImplementedException("ParameterValueGenericFilter: T1 (value) type not implemented!"); } }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { try { uiApp = commandData.Application; uiDoc = uiApp.ActiveUIDocument; app = uiApp.Application; doc = uiDoc.Document; FilteredElementCollector refPlaneCollector = new FilteredElementCollector(doc); IList<Element> refPlanes = refPlaneCollector.OfClass(typeof(ReferencePlane)).ToElements(); ElementId nameParamterId = new ElementId(BuiltInParameter.DATUM_TEXT); ParameterValueProvider pvp = new ParameterValueProvider(nameParamterId); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule(pvp, evaluator, "", false); ElementFilter filter = new ElementParameterFilter(rule); FilteredElementCollector unnamedRefPlaneCollector = new FilteredElementCollector(doc); unnamedRefPlaneCollector.OfClass(typeof(ReferencePlane)); unnamedRefPlaneCollector.WherePasses(filter); IList<Element> unnamedRefPlanes = unnamedRefPlaneCollector.ToElements(); Transaction transaction = new Transaction(doc); transaction.Start("Purging unnamed reference planes"); foreach (Element refPlane in unnamedRefPlanes) doc.Delete(refPlane.Id); transaction.Commit(); TaskDialog.Show("Purge Unnamed Ref Planes", String.Format("{0} reference planes found.\n{1} unnamed reference planes deleted.", refPlanes.Count.ToString(), unnamedRefPlanes.Count.ToString())); return Result.Succeeded; } catch (Exception e) { TaskDialog.Show("Revit Quick Tools", e.Message); return Result.Failed; } }
void f3( Document doc ) { FilteredElementCollector collector = new FilteredElementCollector( doc ); collector.OfClass( typeof( Level ) ); ElementId id = new ElementId( BuiltInParameter.DATUM_TEXT ); ParameterValueProvider provider = new ParameterValueProvider( id ); FilterStringRuleEvaluator evaluator = new FilterStringContains(); FilterRule rule = new FilterStringRule( provider, evaluator, "Level", false ); ElementParameterFilter filter = new ElementParameterFilter( rule ); }
/// <summary> /// Find a specific family type for a wall, which is a system family. /// Most efficient way to find a named family symbol: use a parameter filter. /// </summary> public Element FindFamilyType_Wall_v3( string wallFamilyName, string wallTypeName) { ParameterValueProvider provider = new ParameterValueProvider( new ElementId(BuiltInParameter.DATUM_TEXT)); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule( provider, evaluator, wallTypeName, true); ElementParameterFilter filter = new ElementParameterFilter(rule); return new FilteredElementCollector(_doc) .OfClass(typeof(WallType)) .WherePasses(filter) .FirstElement(); }
/// <summary> /// Return a list of all elements with the /// specified value in their shared parameter with /// the given name oand group. They are retrieved /// using a parameter filter, and the required /// parameter id is found by temporarily adding /// the shared parameter to the project info. /// </summary> static IList<Element> GetElementsMatchingParameter( Document doc, string paramName, string paramGroup, string paramValue) { IList<Element> elems = new List<Element>(); // Determine if definition for parameter binding exists Definition definition = null; BindingMap bm = doc.ParameterBindings; DefinitionBindingMapIterator it = bm.ForwardIterator(); while( it.MoveNext() ) { Definition def = it.Key; if( def.Name.Equals( paramName ) ) { definition = def; break; } } if( definition == null ) { return elems; // parameter binding not defined } using( Transaction tx = new Transaction( doc ) ) { tx.Start( "Set temporary parameter" ); // Temporarily set project information element // parameter in order to determine param.Id FilteredElementCollector collectorPI = new FilteredElementCollector( doc ); collectorPI.OfCategory( BuiltInCategory.OST_ProjectInformation ); Element projInfoElem = collectorPI.FirstElement(); // using http://thebuildingcoder.typepad.com/blog/2012/04/adding-a-category-to-a-shared-parameter-binding.html Parameter param = null; //param = HelperParams.GetOrCreateElemSharedParam( // projInfoElem, paramName, paramGroup, // ParameterType.Text, false, true ); if( param != null ) { ElementId paraId = param.Id; tx.RollBack(); // discard project element change ParameterValueProvider provider = new ParameterValueProvider( paraId ); FilterRule rule = new FilterStringRule( provider, new FilterStringEquals(), paramValue, true ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector collector = new FilteredElementCollector( doc, doc.ActiveView.Id ); elems = collector.WherePasses( filter ) .ToElements(); } } return elems; }
void f2( Document doc, Level level ) { FilteredElementCollector collector = new FilteredElementCollector( doc ); collector.OfCategory( BuiltInCategory.OST_StructuralFraming ); collector.OfClass( typeof( FamilyInstance ) ); BuiltInParameter bip = BuiltInParameter .INSTANCE_REFERENCE_LEVEL_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericGreater(); ElementId idRuleValue = level.Id; FilterElementIdRule rule = new FilterElementIdRule( provider, evaluator, idRuleValue ); ElementParameterFilter filter = new ElementParameterFilter( rule ); collector.WherePasses( filter ); }
/// <summary> /// Return the first wall type with the given name. /// </summary> static WallType GetFirstWallTypeNamed( Document doc, string name) { // built-in parameter storing this // wall type's name: BuiltInParameter bip = BuiltInParameter.SYMBOL_NAME_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule( provider, evaluator, name, false ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector collector = new FilteredElementCollector( doc ) .OfClass( typeof( WallType ) ) .WherePasses( filter ); return collector.FirstElement() as WallType; }
/// <summary> /// Return the all elements that /// use the given ElementType. /// </summary> static FilteredElementCollector GetAllElementsUsingType( Document doc, ElementType et) { // built-in parameter storing the type element id: BuiltInParameter bip = BuiltInParameter.ELEM_TYPE_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); FilterRule rule = new FilterElementIdRule( provider, evaluator, et.Id ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector collector = new FilteredElementCollector( doc ) .WhereElementIsNotElementType() .WherePasses( filter ); return collector; }
/// <summary> /// Retrieve all stairs on a given level. /// </summary> FilteredElementCollector GetStairsOnLevel( Document doc, Level level) { ElementId id = level.Id; BuiltInCategory bic = BuiltInCategory.OST_Stairs; FilteredElementCollector collector = new FilteredElementCollector( doc ); collector.OfCategory( bic ); // explicit iteration and manual // checking of a property: List<Element> stairs = new List<Element>(); foreach( Element e in collector ) { if( e.LevelId.Equals( id ) ) { stairs.Add( e ); } } // using LINQ: IEnumerable<Element> stairsOnLevelLinq = from e in collector where e.LevelId.Equals( id ) select e; // using an anonymous method: IEnumerable<Element> stairsOnLevelAnon = collector.Where<Element>( e => e.LevelId.Equals( id ) ); // using a parameter filter: BuiltInParameter bip = BuiltInParameter.STAIRS_BASE_LEVEL_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); FilterRule rule = new FilterElementIdRule( provider, evaluator, id ); ElementParameterFilter filter = new ElementParameterFilter( rule ); return collector.WherePasses( filter ); }
/// <summary> /// Return the viewport on the given /// sheet displaying the given view. /// </summary> Element GetViewport( ViewSheet sheet, View view ) { Document doc = sheet.Document; // filter for view name: BuiltInParameter bip = BuiltInParameter.VIEW_NAME; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule( provider, evaluator, view.Name, true ); ElementParameterFilter name_filter = new ElementParameterFilter( rule ); BuiltInCategory bic = BuiltInCategory.OST_Viewports; // retrieve the specific named viewport: //Element viewport // = new FilteredElementCollector( doc ) // .OfCategory( bic ) // .WherePasses( name_filter ) // .FirstElement(); //return viewport; // unfortunately, there are not just one, // but two candidate elements. apparently, // we can distibuish them using the // owner view id property: List<Element> viewports = new List<Element>( new FilteredElementCollector( doc ) .OfCategory( bic ) .WherePasses( name_filter ) .ToElements() ); Debug.Assert( viewports[0].OwnerViewId.Equals( ElementId.InvalidElementId ), "expected the first viewport to have an invalid owner view id" ); Debug.Assert( !viewports[1].OwnerViewId.Equals( ElementId.InvalidElementId ), "expected the second viewport to have a valid owner view id" ); int i = 1; return viewports[i]; }
/// <summary> /// Return all elements from the given collector /// whose element id is greater than 'lastId'. /// </summary> FilteredElementCollector GetElementsAfter( FilteredElementCollector input, ElementId lastId) { BuiltInParameter bip = BuiltInParameter.ID_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericGreater(); FilterRule rule = new FilterElementIdRule( provider, evaluator, lastId ); ElementParameterFilter filter = new ElementParameterFilter( rule ); return input.WherePasses( filter ); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument; Application app = uiapp.Application; Document doc = uidoc.Document; Reference r = uidoc.Selection.PickObject( ObjectType.Element ); // 'Autodesk.Revit.DB.Reference.Element' is // obsolete: Property will be removed. Use // Document.GetElement(Reference) instead. //Wall wall = r.Element as Wall; // 2011 Wall wall = doc.GetElement( r ) as Wall; // 2012 //Parameter parameter = wall.get_Parameter( "Unconnected Height" ); // 2014, causes warning CS0618: 'Autodesk.Revit.DB.Element.get_Parameter(string)' is obsolete: 'This property is obsolete in Revit 2015, as more than one parameter can have the same name on a given element. Use Element.Parameters to obtain a complete list of parameters on this Element, or Element.GetParameters(String) to get a list of all parameters by name, or Element.LookupParameter(String) to return the first available parameter with the given name.' Parameter parameter = wall.get_Parameter( BuiltInParameter.WALL_USER_HEIGHT_PARAM ); // 2015, avoids warning, in language indepependent and more effective to look up ParameterValueProvider pvp = new ParameterValueProvider( parameter.Id ); FilterNumericRuleEvaluator fnrv = new FilterNumericGreater(); FilterRule fRule = new FilterDoubleRule( pvp, fnrv, 20, 1E-6 ); ElementParameterFilter filter = new ElementParameterFilter( fRule ); FilteredElementCollector collector = new FilteredElementCollector( doc ); // Find walls with unconnected height // less than or equal to 20: ElementParameterFilter lessOrEqualFilter = new ElementParameterFilter( fRule, true ); IList<Element> lessOrEqualFounds = collector.WherePasses( lessOrEqualFilter ) .OfCategory( BuiltInCategory.OST_Walls ) .OfClass( typeof( Wall ) ) .ToElements(); TaskDialog.Show( "Revit", "Walls found: " + lessOrEqualFounds.Count ); return Result.Succeeded; }
void f4( Document doc ) { // Use numeric evaluator and integer rule to test ElementId parameter // Filter levels whose id is greater than specified id value BuiltInParameter testParam = BuiltInParameter.ID_PARAM; ParameterValueProvider pvp = new ParameterValueProvider( new ElementId( (int) testParam ) ); FilterNumericRuleEvaluator fnrv = new FilterNumericGreater(); // filter elements whose Id is greater than 99 ElementId ruleValId = new ElementId( 99 ); FilterRule paramFr = new FilterElementIdRule( pvp, fnrv, ruleValId ); ElementParameterFilter epf = new ElementParameterFilter( paramFr ); FilteredElementCollector collector = new FilteredElementCollector( doc ); collector.OfClass( typeof( ViewPlan ) ) .WherePasses( epf ); // only deal with ViewPlan // Use numeric evaluator and integer rule to test bool parameter // Filter levels whose crop view is false int ruleValInt = 0; testParam = BuiltInParameter.VIEWER_CROP_REGION; pvp = new ParameterValueProvider( new ElementId( (int) testParam ) ); fnrv = new FilterNumericEquals(); paramFr = new FilterIntegerRule( pvp, fnrv, ruleValInt ); epf = new ElementParameterFilter( paramFr ); collector = new FilteredElementCollector( doc ); collector.OfClass( typeof( ViewPlan ) ) .WherePasses( epf ); // only deal with ViewPlan // Use numeric evaluator and double rule to test double parameter // Filter levels whose top offset is greater than specified value double ruleValDb = 10; testParam = BuiltInParameter.VIEWER_BOUND_OFFSET_TOP; pvp = new ParameterValueProvider( new ElementId( (int) testParam ) ); fnrv = new FilterNumericGreater(); paramFr = new FilterDoubleRule( pvp, fnrv, ruleValDb, double.Epsilon ); collector = new FilteredElementCollector( doc ); collector.OfClass( typeof( ViewPlan ) ) .WherePasses( epf ); // only deal with ViewPlan // Use string evaluator and string rule to test string parameter // Filter all elements whose view name contains level String ruleValStr = "Level"; testParam = BuiltInParameter.VIEW_NAME; pvp = new ParameterValueProvider( new ElementId( (int) testParam ) ); FilterStringRuleEvaluator fnrvStr = new FilterStringContains(); paramFr = new FilterStringRule( pvp, fnrvStr, ruleValStr, false ); collector = new FilteredElementCollector( doc ); collector.OfClass( typeof( ViewPlan ) ) .WherePasses( epf ); // only deal with ViewPlan }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument; Application app = uiapp.Application; Document doc = uidoc.Document; // Construct a parameter filter to get only // unnamed reference planes, i.e. reference // planes whose name equals the empty string: BuiltInParameter bip = BuiltInParameter.DATUM_TEXT; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterStringRule rule = new FilterStringRule( provider, evaluator, "", false ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector col = new FilteredElementCollector( doc ) .OfClass( typeof( ReferencePlane ) ) .WherePasses( filter ); int n = 0; int nDeleted = 0; // No need to cast ... this is pretty nifty, // I find ... grab the elements as ReferencePlane // instances, since the filter guarantees that // only ReferencePlane instances are selected. // In Revit 2014, this attempt to delete the // reference planes while iterating over the // filtered element collector throws an exception: // Autodesk.Revit.Exceptions.InvalidOperationException: // HResult=-2146233088 // Message=The iterator cannot proceed due to // changes made to the Element table in Revit's // database (typically, This can be the result // of an Element deletion). // //foreach( ReferencePlane rp in col ) //{ // ++n; // nDeleted += DeleteIfNotHosting( rp ) ? 1 : 0; //} ICollection<ElementId> ids = col.ToElementIds(); n = ids.Count(); if( 0 < n ) { using( Transaction tx = new Transaction( doc ) ) { tx.Start( string.Format( "Delete {0} ReferencePlane{1}", n, Util.PluralSuffix( n ) ) ); // This also causes the exception "One or more of // the elementIds cannot be deleted. Parameter // name: elementIds // //ICollection<ElementId> ids2 = doc.Delete( // ids ); //nDeleted = ids2.Count(); List<ElementId> ids2 = new List<ElementId>( ids ); foreach( ElementId id in ids2 ) { try { ICollection<ElementId> ids3 = doc.Delete( id ); nDeleted += ids3.Count; } catch( Autodesk.Revit.Exceptions.ArgumentException ) { } } tx.Commit(); } } Util.InfoMsg( string.Format( "{0} unnamed reference plane{1} examined, " + "{2} element{3} in total were deleted.", n, Util.PluralSuffix( n ), nDeleted, Util.PluralSuffix( nDeleted ) ) ); return Result.Succeeded; }
/// <summary> /// Return the first wall found that /// uses the given wall type. /// </summary> static Wall GetFirstWallUsingType( Document doc, WallType wallType) { // built-in parameter storing this // wall's wall type element id: BuiltInParameter bip = BuiltInParameter.ELEM_TYPE_PARAM; ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); FilterRule rule = new FilterElementIdRule( provider, evaluator, wallType.Id ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector collector = new FilteredElementCollector( doc ) .OfClass( typeof( Wall ) ) .WherePasses( filter ); return collector.FirstElement() as Wall; }
/// <summary> /// Optional - example of parameter filter. /// Find walls whose length is longer than a certain length. e.g., 60 feet /// wall.parameter(length) > 60 feet /// This could get more complex than looping through in terms of writing a code. /// See page 87 of Developer guide. /// </summary> public IList<Element> FindLongWalls() { // Constant for this function. const double kWallLength = 60.0; // 60 feet. hard coding for simplicity. // First, narrow down to the elements of the given type and category var collector = new FilteredElementCollector(_doc).OfClass(typeof(Wall)); // Define a filter by parameter // 1st arg - value provider BuiltInParameter lengthParam = BuiltInParameter.CURVE_ELEM_LENGTH; int iLengthParam = (int)lengthParam; var paramValueProvider = new ParameterValueProvider(new ElementId(iLengthParam)); // 2nd - evaluator FilterNumericGreater evaluator = new FilterNumericGreater(); // 3rd - rule value double ruleVal = kWallLength; // 4th - epsilon const double eps = 1E-06; // Define a rule var filterRule = new FilterDoubleRule(paramValueProvider, evaluator, ruleVal, eps); // Create a new filter var paramFilter = new ElementParameterFilter(filterRule); // Go through the filter IList<Element> elems = collector.WherePasses(paramFilter).ToElements(); return elems; }
public Result Execute( ExternalCommandData commandData, ref string messages, ElementSet elements) { UIApplication app = commandData.Application; Document doc = app.ActiveUIDocument.Document; ElementId id = new ElementId( BuiltInParameter.ELEM_ROOM_NUMBER ); ParameterValueProvider provider = new ParameterValueProvider( id ); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); string sRoomNumber = "1"; FilterRule rule = new FilterStringRule( provider, evaluator, sRoomNumber, false ); ElementParameterFilter filter = new ElementParameterFilter( rule ); FilteredElementCollector collector = new FilteredElementCollector( doc ); string s = string.Empty; foreach( Element e in collector ) { s += e.Name + e.Category.Name.ToString() + "\n"; } System.Windows.Forms.MessageBox.Show( s ); return Result.Succeeded; }
private static void HostedFamilyInstanceOpenings(Wall wall, double minOpeningValue) { double wallOpeningArea = 0.0; double wallTotalOpeningArea = 0.0; // Filter all Family Instances where the HOST_ID_PARAM // equals the wall ID // // More information at // http://thebuildingcoder.typepad.com/ // blog/2010/06/parameter-filter.html#4 BuiltInParameter testParam = BuiltInParameter.HOST_ID_PARAM; ParameterValueProvider pvp = new ParameterValueProvider( new ElementId((int)testParam)); FilterNumericRuleEvaluator fnrv = new FilterNumericEquals(); ElementId ruleValId = wall.Id; FilterRule paramFr = new FilterElementIdRule (pvp, fnrv, ruleValId); ElementParameterFilter epf = new ElementParameterFilter(paramFr); FilteredElementCollector collector = new FilteredElementCollector(wall.Document); collector.OfClass(typeof(FamilyInstance)).WherePasses(epf); IList<Element> hostedFamilyInstances = collector.ToElements(); // Now iterate through the collected family instances Document doc = wall.Document; double previousArea = wall.get_Parameter( BuiltInParameter.HOST_AREA_COMPUTED).AsDouble(); foreach (FamilyInstance instance in hostedFamilyInstances) { // Delete the hosted family instace and regenerate doc.Delete(instance); doc.Regenerate(); // Get the new area to compare double newArea = wall.get_Parameter( BuiltInParameter.HOST_AREA_COMPUTED).AsDouble(); // So the instance opening equals: double instanceAreaOnTheWall = Math.Abs(newArea - previousArea); // The element area (on wall) is smaller than // the minOpeningValue? if (instanceAreaOnTheWall <= minOpeningValue) wallOpeningArea += instanceAreaOnTheWall; else wallTotalOpeningArea += instanceAreaOnTheWall; if (System.Diagnostics.Debugger.IsAttached) TaskDialog.Show( "Wall opening (by inst) found (in sq feet)", string.Format("Area: {0}", instanceAreaOnTheWall)); previousArea = newArea; } AddWallArea(wall.Id, wallOpeningArea, wallTotalOpeningArea); }
public Result Execute( ExternalCommandData commandData, ref string messages, ElementSet elements) { UIApplication app = commandData.Application; Document doc = app.ActiveUIDocument.Document; Transaction tx = new Transaction( doc, "Test" ); tx.Start(); // use the view filter FilteredElementCollector collector = new FilteredElementCollector( doc, doc.ActiveView.Id ); // use the parameter filter. // get the phase id "New construction" ElementId idPhase = GetPhaseId( "New Construction", doc ); ParameterValueProvider provider = new ParameterValueProvider( new ElementId( (int) BuiltInParameter.PHASE_CREATED ) ); FilterNumericRuleEvaluator evaluator = new FilterNumericEquals(); FilterElementIdRule rule = new FilterElementIdRule( provider, evaluator, idPhase ); ElementParameterFilter parafilter = new ElementParameterFilter( rule ); collector.WherePasses( parafilter ); TaskDialog.Show( "Element Count", "There are " + collector.Count().ToString() + " elements in the current view created" + " with phase New Construction" ); tx.Commit(); return Result.Succeeded; }
/// <summary> /// Use a parameter filter to return the first element /// of the given type and with the specified string-valued /// built-in parameter matching the given name. /// </summary> Element GetFirstElementOfTypeWithBipString( Type type, BuiltInParameter bip, string name) { FilteredElementCollector a = GetElementsOfType( type ); ParameterValueProvider provider = new ParameterValueProvider( new ElementId( bip ) ); FilterStringRuleEvaluator evaluator = new FilterStringEquals(); FilterRule rule = new FilterStringRule( provider, evaluator, name, true ); ElementParameterFilter filter = new ElementParameterFilter( rule ); return a.WherePasses( filter ).FirstElement(); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument; Application app = uiapp.Application; Document doc = uidoc.Document; Reference r = uidoc.Selection.PickObject( ObjectType.Element ); // 'Autodesk.Revit.DB.Reference.Element' is // obsolete: Property will be removed. Use // Document.GetElement(Reference) instead. //Wall wall = r.Element as Wall; // 2011 Wall wall = doc.GetElement( r ) as Wall; // 2012 Parameter parameter = wall.get_Parameter( "Unconnected Height" ); ParameterValueProvider pvp = new ParameterValueProvider( parameter.Id ); FilterNumericRuleEvaluator fnrv = new FilterNumericGreater(); FilterRule fRule = new FilterDoubleRule( pvp, fnrv, 20, 1E-6 ); ElementParameterFilter filter = new ElementParameterFilter( fRule ); FilteredElementCollector collector = new FilteredElementCollector( doc ); // Find walls with unconnected height // less than or equal to 20: ElementParameterFilter lessOrEqualFilter = new ElementParameterFilter( fRule, true ); IList<Element> lessOrEqualFounds = collector.WherePasses( lessOrEqualFilter ) .OfCategory( BuiltInCategory.OST_Walls ) .OfClass( typeof( Wall ) ) .ToElements(); TaskDialog.Show( "Revit", "Walls found: " + lessOrEqualFounds.Count ); return Result.Succeeded; }