/// <summary>
/// Convert FilterRule to our custom FilterRuleBuilder which will be displayed in form controls
/// </summary>
/// <param name="param">Parameter to which the FilterRule is applied.</param>
/// <param name="rule">FilterRule to be converted.</param>
/// <returns>Custom FilterRuleBuilder data converted from FilterRule</returns>
public static FilterRuleBuilder CreateFilterRuleBuilder(BuiltInParameter param, FilterRule rule)
{
// Maybe FilterRule is inverse rule, we need to find its inner rule(FilterValueRule)
// Note that the rule may be inversed more than once.
bool inverted = false;
FilterRule innerRule = ReflectToInnerRule(rule, out inverted);
if (innerRule is FilterStringRule)
{
FilterStringRule strRule = innerRule as FilterStringRule;
FilterStringRuleEvaluator evaluator = strRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), strRule.RuleString, strRule.RuleString.ToLower() == strRule.RuleString ? false : true));
}
else if (innerRule is FilterDoubleRule)
{
FilterDoubleRule dbRule = innerRule as FilterDoubleRule;
FilterNumericRuleEvaluator evaluator = dbRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), dbRule.RuleValue, dbRule.Epsilon));
}
else if (innerRule is FilterIntegerRule)
{
FilterIntegerRule intRule = innerRule as FilterIntegerRule;
FilterNumericRuleEvaluator evaluator = intRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), intRule.RuleValue));
}
else if (innerRule is FilterElementIdRule)
{
FilterElementIdRule idRule = innerRule as FilterElementIdRule;
FilterNumericRuleEvaluator evaluator = idRule.GetEvaluator();
return(new FilterRuleBuilder(param, GetEvaluatorCriteriaName(evaluator, inverted), idRule.RuleValue));
}
//
// for other rule, not supported yet
throw new System.NotImplementedException("The filter rule is not recognizable and supported yet!");
}
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);
}
/// <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!");
}
}
private IList <Element> GetElementValueIntOrstring(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue)
{
IList <Element> vResult = new List <Element>();
IList <Element> vResultTemp = new List <Element>();
foreach (var vCategoryId in valCategoryElementId)
{
IList <ElementFilter> vList = new List <ElementFilter>();
BuiltInCategory vBuiltInCategory = (BuiltInCategory)vCategoryId.IntegerValue;
ParameterValueProvider vPovider = new ParameterValueProvider(valRevitParameter.ElementId);
string vRulestring = valValue;
FilterStringRuleEvaluator vEvaluator = new FilterStringEquals();
FilteredElementCollector vCollector = new FilteredElementCollector(_Doc);
vCollector.OfCategory(vBuiltInCategory);
FilterRule vRuleRulestring = new FilterStringRule(vPovider, vEvaluator, vRulestring, false);
ElementParameterFilter vFilterRulestring = new ElementParameterFilter(vRuleRulestring);
LibNumeric insLibNumeric = new LibNumeric();
if (insLibNumeric.IsInt(valValue))
{
int vNum = 0;
int.TryParse(valValue, out vNum);
FilterNumericEquals vEvaluatorNumeri = new FilterNumericEquals();
int vRuleIntVal = vNum;
var vFilterIntRule = new FilterIntegerRule(vPovider, vEvaluatorNumeri, vRuleIntVal);
var vElementParameterFilterIntRule = new ElementParameterFilter(vFilterIntRule);
vList.Add(vElementParameterFilterIntRule);
}
vList.Add(vFilterRulestring);
LogicalOrFilter vLogicalOrFilter = new LogicalOrFilter(vList);
vCollector.WherePasses(vLogicalOrFilter);
IList <Element> vElements = vCollector.ToElements();
if (vElements != null)
{
if (vElements.Count > 0)
{
foreach (var vElement in vElements)
{
vResult.Add(vElement);
}
}
}
}
return(vResult);
}
public static List <LinkElementId> FindExteriorWallsByParameterValues(Document doc, bool isHost, ElementId linkInstanceId)
{
List <LinkElementId> exteriorElementIds = new List <LinkElementId>();
try
{
FilteredElementCollector collector = new FilteredElementCollector(doc);
Wall wall = collector.OfCategory(BuiltInCategory.OST_Walls).WhereElementIsNotElementType().ToElements().Cast <Wall>().First();
Parameter param = wall.LookupParameter(LEEDParameters.LEED_IsExteriorWall.ToString());
ElementId paramId = ElementId.InvalidElementId;
if (null != param)
{
paramId = param.Id;
}
ParameterValueProvider pvp = new ParameterValueProvider(paramId);
FilterNumericEquals fnrv = new FilterNumericEquals();
FilterIntegerRule paramFr = new FilterIntegerRule(pvp, fnrv, 1);
ElementParameterFilter paramFilter = new ElementParameterFilter(paramFr);
collector = new FilteredElementCollector(doc);
List <ElementId> eIds = collector.OfCategory(BuiltInCategory.OST_Walls).WhereElementIsNotElementType().WherePasses(paramFilter).ToElementIds().ToList();
foreach (ElementId eId in eIds)
{
if (isHost)
{
LinkElementId linkId = new LinkElementId(eId);
exteriorElementIds.Add(linkId);
}
else
{
LinkElementId linkId = new LinkElementId(linkInstanceId, eId);
exteriorElementIds.Add(linkId);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to find exterior walls.\n" + ex.Message, "Find Exterior Walls by Parameter", MessageBoxButton.OK, MessageBoxImage.Warning);
}
return(exteriorElementIds);
}
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
}
protected override void SolveInstance(IGH_DataAccess DA)
{
var parameterId = ElementId.InvalidElementId;
if (!DA.GetData("ParameterKey", ref parameterId))
{
return;
}
DA.DisableGapLogic();
if (!TryGetParameterDefinition(Revit.ActiveDBDocument, parameterId, out var storageType, out var parameterType))
{
if (parameterId.TryGetBuiltInParameter(out var builtInParameter))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{LabelUtils.GetLabelFor(builtInParameter)}' in Revit document.");
}
else
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{parameterId.IntegerValue}' in Revit document.");
}
return;
}
var provider = new ParameterValueProvider(parameterId);
Autodesk.Revit.DB.FilterRule rule = null;
if (storageType == StorageType.String)
{
FilterStringRuleEvaluator ruleEvaluator = null;
switch (Condition)
{
case ConditionType.NotEquals:
case ConditionType.Equals: ruleEvaluator = new FilterStringEquals(); break;
case ConditionType.Greater: ruleEvaluator = new FilterStringGreater(); break;
case ConditionType.GreaterOrEqual: ruleEvaluator = new FilterStringGreaterOrEqual(); break;
case ConditionType.Less: ruleEvaluator = new FilterStringLess(); break;
case ConditionType.LessOrEqual: ruleEvaluator = new FilterStringLessOrEqual(); break;
}
var goo = default(GH_String);
if (DA.GetData("Value", ref goo))
{
rule = new FilterStringRule(provider, ruleEvaluator, goo.Value, true);
}
}
else
{
FilterNumericRuleEvaluator ruleEvaluator = null;
switch (Condition)
{
case ConditionType.NotEquals:
case ConditionType.Equals: ruleEvaluator = new FilterNumericEquals(); break;
case ConditionType.Greater: ruleEvaluator = new FilterNumericGreater(); break;
case ConditionType.GreaterOrEqual: ruleEvaluator = new FilterNumericGreaterOrEqual(); break;
case ConditionType.Less: ruleEvaluator = new FilterNumericLess(); break;
case ConditionType.LessOrEqual: ruleEvaluator = new FilterNumericLessOrEqual(); break;
}
switch (storageType)
{
case StorageType.Integer:
{
var goo = default(GH_Integer);
if (DA.GetData("Value", ref goo))
{
rule = new FilterIntegerRule(provider, ruleEvaluator, goo.Value);
}
}
break;
case StorageType.Double:
{
var goo = default(GH_Number);
if (DA.GetData("Value", ref goo))
{
if (Condition == ConditionType.Equals || Condition == ConditionType.NotEquals)
{
if (parameterType == ParameterType.Length || parameterType == ParameterType.Area || parameterType == ParameterType.Volume)
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), ToHost(Revit.VertexTolerance, parameterType));
}
else
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 1e-6);
}
}
else
{
rule = new FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 0.0);
}
}
}
break;
case StorageType.ElementId:
{
switch (parameterType)
{
case (ParameterType)int.MaxValue: // Category
{
var value = default(Types.Category);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
case ParameterType.FamilyType:
{
var value = default(Types.ElementType);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
default:
{
var value = default(Types.Element);
if (DA.GetData("Value", ref value))
{
rule = new FilterElementIdRule(provider, ruleEvaluator, value);
}
}
break;
}
}
break;
}
}
if (rule is object)
{
if (Condition == ConditionType.NotEquals)
{
DA.SetData("Rule", new FilterInverseRule(rule));
}
else
{
DA.SetData("Rule", rule);
}
}
}
//Private Method
private static string CastFilterRule(FilterRule r)
{
if (r is FilterStringRule)
{
FilterStringRule filterRule = r as FilterStringRule;
FilterStringRuleEvaluator evaluator = filterRule.GetEvaluator();
if (filterRule.GetEvaluator() is FilterStringBeginsWith)
{
return("FilterStringBeginsWith");
}
else if (filterRule.GetEvaluator() is FilterStringContains)
{
return("FilterStringContains");
}
else if (filterRule.GetEvaluator() is FilterStringEndsWith)
{
return("FilterStringEndsWith");
}
else if (filterRule.GetEvaluator() is FilterStringEquals)
{
return("FilterStringEquals");
}
else if (filterRule.GetEvaluator() is FilterStringGreaterOrEqual)
{
return("FilterStringGreaterOrEqual");
}
else if (filterRule.GetEvaluator() is FilterStringLess)
{
return("FilterStringLess");
}
else if (filterRule.GetEvaluator() is FilterStringLessOrEqual)
{
return("FilterStringLessOrEqual");
}
}
else if (r is FilterIntegerRule || r is FilterDoubleRule || r is FilterGlobalParameterAssociationRule)
{
FilterIntegerRule filterRule = r as FilterIntegerRule;
FilterNumericRuleEvaluator evaluator = filterRule.GetEvaluator();
if (filterRule.GetEvaluator() is FilterNumericEquals)
{
return("FilterNumericEquals");
}
else if (filterRule.GetEvaluator() is FilterNumericGreater)
{
return("FilterNumericGreater");
}
else if (filterRule.GetEvaluator() is FilterNumericGreaterOrEqual)
{
return("FilterNumericGreaterOrEqual");
}
else if (filterRule.GetEvaluator() is FilterNumericLess)
{
return("FilterNumericLess");
}
else if (filterRule.GetEvaluator() is FilterNumericLessOrEqual)
{
return("FilterNumericLessOrEqual");
}
}
else if (r is FilterInverseRule)
{
FilterInverseRule filterRule = r as FilterInverseRule;
FilterRule innerRule = filterRule.GetInnerRule();
return(CastFilterRule(innerRule) + "_InnerRule");
}
else if (r is SharedParameterApplicableRule)
{
return("SharedParameterApplicableRule");
}
;
return(null);
}
private ElementFilter CreateParamFilter(int paramId, string strOperator, string paramValue, bool emptyValue)
{
try
{
ParameterProperties pp = selectedParameters[paramId];
ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(pp.ParamId));
switch (pp.ParamStorageType)
{
case StorageType.ElementId:
if (pp.ParamName == "Phase Created" || pp.ParamName == "Phase Demolished")
{
FilterNumericRuleEvaluator fnre1 = new FilterNumericEquals();
var phaseId = from phase in phases where phase.Value.Name == paramValue select phase.Key;
int pId = phaseId.First();
ElementId ruleValId = new ElementId(pId);
FilterRule filterRule1 = new FilterElementIdRule(pvp, fnre1, ruleValId);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule1, true));
}
else
{
return(new ElementParameterFilter(filterRule1));
}
}
return(null);
case StorageType.Double:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterDoubleRule doubleRule = new FilterDoubleRule(pvp, fnre, 0, double.Epsilon);
return(new ElementParameterFilter(doubleRule, true));
}
FilterNumericRuleEvaluator fnre2 = FindFilterNumericRuleEvaluator(strOperator);
double dblValue = 0;
if (!string.IsNullOrEmpty(paramValue))
{
double.TryParse(paramValue, out dblValue);
}
FilterRule filterRule2 = new FilterDoubleRule(pvp, fnre2, dblValue, double.Epsilon);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule2, true));
}
else
{
return(new ElementParameterFilter(filterRule2));
}
case StorageType.Integer:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterIntegerRule integerRule = new FilterIntegerRule(pvp, fnre, 0);
return(new ElementParameterFilter(integerRule, true));
}
FilterNumericRuleEvaluator fnre3 = FindFilterNumericRuleEvaluator(strOperator);
int intValue = 0;
if (pp.ParamName == "Workset")
{
var worksetId = from ws in worksets where ws.Value.Name == paramValue select ws.Key;
intValue = worksetId.First();
}
else if (!string.IsNullOrEmpty(paramValue))
{
int.TryParse(paramValue, out intValue);
}
FilterRule filterRule3 = new FilterIntegerRule(pvp, fnre3, intValue);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule3, true));
}
else
{
return(new ElementParameterFilter(filterRule3));
}
case StorageType.String:
if (emptyValue)
{
FilterStringRuleEvaluator fsre = new FilterStringGreater();
FilterStringRule stringRule = new FilterStringRule(pvp, fsre, "", false);
return(new ElementParameterFilter(stringRule, true));
}
FilterStringRuleEvaluator fnre4 = FindFilterStringRuleEvaluator(strOperator);
string strValue = paramValue;
FilterStringRule filterRule4 = new FilterStringRule(pvp, fnre4, strValue, false);
if (strOperator.Contains("does not"))
{
return(new ElementParameterFilter(filterRule4, true));
}
else
{
return(new ElementParameterFilter(filterRule4, false));
}
default:
return(null);
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to create parameter filters.\n" + ex.Message, "CreateParamFilter", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(null);
}
