Ejemplo n.º 1
0
def filter_rule(para, param_equality, value):
    param_id = DB.ElementId(para)
    param_prov = DB.ParameterValueProvider(param_id)

    value_rule = DB.FilterDoubleRule(param_prov, param_equality(), value,
                                     1e-3 / 0.3048)  # tolerance of 1 mm
    param_filter = DB.ElementParameterFilter(value_rule)
    return param_filter
Ejemplo n.º 2
0
def find_ins_wall(width):
    # which parameter to look at
    parameter_value_provider = DB.ParameterValueProvider(
        DB.ElementId(DB.BuiltInParameter.WALL_ATTR_WIDTH_PARAM))
    # construct filter rule
    width_rule = DB.FilterDoubleRule(parameter_value_provider,
                                     DB.FilterNumericEquals(), width, 10e-10)
    # using slow parameter filter
    width_filter = DB.ElementParameterFilter(width_rule)
    # filter wall types of same width as insulation layer
    width_wall_types = DB.FilteredElementCollector(revit.doc) \
        .OfCategory(DB.BuiltInCategory.OST_Walls) \
        .WhereElementIsElementType() \
        .WherePasses(width_filter) \
        .ToElements()
    # iterate through wall types to find one that have one layer of insulation
    for wt in width_wall_types:
        compound_str = wt.GetCompoundStructure()
        num = compound_str.LayerCount
        if num == 1 and str(compound_str.GetLayerFunction(0)) == "Insulation":
            return wt
Ejemplo n.º 3
0
doc = __revit__.ActiveUIDocument.Document
uidoc = __revit__.ActiveUIDocument
curview = doc.ActiveView  # gets current view

if isinstance(curview, DB.ViewSheet):
    forms.alert("You're on a Sheet. Activate a model view please.",
                exitscript=True)

length_feet = float(forms.ask_for_string(
    "Enter length in meters")) / 0.3048  # sometimes revit interprets 1 > 1.0
target_parameter = DB.BuiltInParameter.CURVE_ELEM_LENGTH  # FAMILY_TOP_LEVEL_PARAM, FAMILY_BASE_LEVEL_PARAM
param_id = DB.ElementId(target_parameter)
param_prov = DB.ParameterValueProvider(param_id)
param_equality = DB.FilterNumericEquals()  # equality class

value_rule = DB.FilterDoubleRule(param_prov, param_equality, length_feet,
                                 1e-3 / 0.3048)  # tolerance of 1 mm
param_filter = DB.ElementParameterFilter(value_rule)

same_cat_elements = \
        DB.FilteredElementCollector(doc,curview.Id)\
          .OfCategory(DB.BuiltInCategory.OST_Walls)\
          .WhereElementIsNotElementType()\
          .WherePasses(param_filter)\
          .ToElements()

filered_elements = []

for sim_element in same_cat_elements:
    r_type = sim_element.GetTypeId()
    # if r_type == type_id: # for same family type
    filered_elements.append(sim_element.Id)
Ejemplo n.º 4
0
    category_id = ele.Category.Id
    type_id = ele.GetTypeId()
    if category_name == "Walls":
        cparam = ele.Parameter[DB.BuiltInParameter.WALL_USER_HEIGHT_PARAM]
        cparam = cparam.AsDouble()*.3048
        target_parameter =  DB.BuiltInParameter.WALL_USER_HEIGHT_PARAM # FAMILY_TOP_LEVEL_PARAM, FAMILY_BASE_LEVEL_PARAM
    else:
        cparam = ele.Parameter[DB.BuiltInParameter.INSTANCE_LENGTH_PARAM]
        cparam = cparam.AsDouble()*.3048
        target_parameter =  DB.BuiltInParameter.INSTANCE_LENGTH_PARAM # FAMILY_TOP_LEVEL_PARAM, FAMILY_BASE_LEVEL_PARAM
    
param_id = DB.ElementId(target_parameter)
param_prov = DB.ParameterValueProvider(param_id)
param_equality = DB.FilterNumericEquals() # equality class
    
value_rule = DB.FilterDoubleRule(param_prov,param_equality,cparam/0.3048 ,0.5) # 0.5 will give us a tolerance of 304.8 mm
param_filter = DB.ElementParameterFilter(value_rule)

same_cat_elements = \
        DB.FilteredElementCollector(revit.doc, curview.Id)\
          .OfCategoryId(category_id)\
          .WhereElementIsNotElementType()\
          .WherePasses(param_filter)\
          .ToElements()
          
filered_elements = []    

for sim_element in same_cat_elements:
    r_type = sim_element.GetTypeId()
    if r_type == type_id:
        filered_elements.append(sim_element.Id)
Ejemplo n.º 5
0
def create_param_value_filter(filter_name,
                              param_id,
                              param_values,
                              evaluator,
                              match_any=True,
                              case_sensitive=False,
                              exclude=False,
                              category_list=None,
                              doc=None):
    doc = doc or DOCS.doc

    if HOST_APP.is_newer_than(2019, or_equal=True):
        rules = None
    else:
        rules = framework.List[DB.FilterRule]()
    param_prov = DB.ParameterValueProvider(param_id)

    # decide how to combine the rules
    logical_merge = \
        DB.LogicalOrFilter if match_any else DB.LogicalAndFilter

    # create the rule set
    for pvalue in param_values:
        # grab the evaluator
        param_eval = PARAM_VALUE_EVALUATORS.get(evaluator, None)
        if not param_eval:
            raise PyRevitException("Unknown evaluator")

        # if value is str, eval is expected to be str
        str_eval, num_eval = param_eval
        if isinstance(pvalue, str):
            rule = DB.FilterStringRule(param_prov, str_eval(), pvalue,
                                       case_sensitive)
        # if num_eval is for str, e.g. "contains", or "startswith"
        # convert numeric values to str
        elif isinstance(num_eval, DB.FilterStringRuleEvaluator):
            if isinstance(pvalue, (int, float)):
                rule = DB.FilterStringRule(param_prov, num_eval(), str(pvalue),
                                           False)
            elif isinstance(pvalue, DB.ElementId):
                rule = DB.FilterStringRule(param_prov, num_eval(),
                                           str(pvalue.IntegerValue), False)
        # if value is int, eval is expected to be numeric
        elif isinstance(pvalue, int):
            rule = DB.FilterIntegerRule(param_prov, num_eval(), pvalue)
        # if value is float, eval is expected to be numeric
        elif isinstance(pvalue, float):
            rule = DB.FilterDoubleRule(param_prov, num_eval(), pvalue,
                                       sys.float_info.epsilon)
        # if value is element id, eval is expected to be numeric
        elif isinstance(pvalue, DB.ElementId):
            rule = DB.FilterElementIdRule(param_prov, num_eval(), pvalue)
        if exclude:
            rule = DB.FilterInverseRule(rule)

        if HOST_APP.is_newer_than(2019, or_equal=True):
            if rules:
                rules = logical_merge(rules, DB.ElementParameterFilter(rule))
            else:
                rules = DB.ElementParameterFilter(rule)
        else:
            rules.Add(rule)

    # collect applicable categories
    if category_list:
        category_set = query.get_category_set(category_list, doc=doc)
    else:
        category_set = query.get_all_category_set(doc=doc)

    # filter the applicable categories
    filter_cats = []
    for cat in category_set:
        if DB.ParameterFilterElement.AllRuleParametersApplicable(
                doc, framework.List[DB.ElementId]([cat.Id]), rules):
            filter_cats.append(cat.Id)

    # create filter
    return DB.ParameterFilterElement.Create(
        doc, filter_name, framework.List[DB.ElementId](filter_cats), rules)