def get_elements_by_param_value(param_name,
param_value,
inverse=False,
doc=None):
doc = doc or HOST_APP.doc
param_id = get_project_parameter_id(param_name)
if param_id:
pvprov = DB.ParameterValueProvider(param_id)
pfilter = DB.FilterStringEquals()
vrule = DB.FilterStringRule(pvprov, pfilter, param_value, True)
if inverse:
vrule = DB.FilterInverseRule(vrule)
param_filter = DB.ElementParameterFilter(vrule)
return DB.FilteredElementCollector(doc)\
.WherePasses(param_filter)\
.ToElements()
else:
return []
def get_vp_by_name(name, doc=revit.doc):
#
bip_id = DB.ElementId(DB.BuiltInParameter.VIEWPORT_ATTR_SHOW_LABEL)
bip_provider = DB.ParameterValueProvider(bip_id)
rule = DB.FilterIntegerRule(bip_provider, DB.FilterNumericGreaterOrEqual(), 0)
param_filter = DB.ElementParameterFilter(rule)
type_bip_id = DB.ElementId(DB.BuiltInParameter.ALL_MODEL_TYPE_NAME)
type_bip_provider = DB.ParameterValueProvider(type_bip_id)
type_filter_rule = DB.FilterStringRule(type_bip_provider, DB.FilterStringEquals(), name, True)
type_filter = DB.ElementParameterFilter(type_filter_rule)
and_filter = DB.LogicalAndFilter(param_filter, type_filter)
collector = DB.FilteredElementCollector(doc) \
.WherePasses(and_filter) \
.WhereElementIsElementType()\
.FirstElement()
return collector
# para = para.lower()
# if para == target_tag.lower():
# wall_id.append(wall.Id) # returns element id
# wall_id_list = List[DB.ElementId](wall_id)
# try:
# uidoc.Selection.SetElementIds(wall_id_list)
# except :
# forms.alert("Tag \"{0}\" not found!!!".format(target_tag))
# pass
if True:
param_id = DB.ElementId(target_parameter)
param_prov = DB.ParameterValueProvider(param_id)
param_equality = DB.FilterStringEquals() # equality class
value_rule = DB.FilterStringRule(param_prov,param_equality,target_tag ,True)
param_filter = DB.ElementParameterFilter(value_rule)
elements = DB.FilteredElementCollector(doc)\
.OfCategory(target_category)\
.WhereElementIsNotElementType()\
.WherePasses(param_filter)\
.ToElementIds() # select category based on the rule
if elements:
uidoc.Selection.SetElementIds(elements)
else:
forms.alert("Tag \"{0}\" not found!!!".format(target_tag))
except: # exception to deal with user exiting form
pass
viewTypeId = threeD_view.GetTypeId()
today = date.today()
today = today.strftime("%m/%d/%Y")
with forms.WarningBar(title="Pick source object:"):
source_elements = revit.pick_elements()
values = []
if source_elements:
# Get all SSG Families
mfg_param_id = DB.ElementId(DB.BuiltInParameter.ALL_MODEL_MANUFACTURER)
mfg_param_prov = DB.ParameterValueProvider(mfg_param_id)
param_contains = DB.FilterStringContains()
mfg_value_rule = DB.FilterStringRule(mfg_param_prov, param_contains,
"Southwest Solutions Group", False)
param_filter = DB.ElementParameterFilter(mfg_value_rule)
ssg_fams = (DB.FilteredElementCollector(revit.doc).WherePasses(
param_filter).WhereElementIsNotElementType().ToElements())
# Get the secondary titleblock
title_blocks = (DB.FilteredElementCollector(revit.doc).OfCategory(
DB.BuiltInCategory.OST_TitleBlocks).WhereElementIsElementType())
pdf_tb = [
t for t in title_blocks
if t.FamilyName + ": " + t.LookupParameter("Type Name").AsString() ==
"SSG_TB_8.5x11_PDF: Primary"
][0]
pdf_tb_2 = [
t for t in title_blocks if t.FamilyName + ": " +
t.LookupParameter("Type Name").AsString() == "SSG_TB_8.5x11_PDF: Empty"
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)
def create_tag_filter(tags, name_format=None, exclude=False):
"""Create standard rule-based filters for given tags (max of 3 tags).
Args:
tags (list[Tag]): list of tags to create filter for (max of 3)
name_format (str, optional): format for naming the filter,
must include `{all_or_none}` and `{tag_names}`.
exclude (bool, optional): create exclusion filter, defaults to False
Returns:
list[DB.ParameterFilterElement]: list of created filters
Example:
>>> import tagsmgr
>>> fname = 'CUSTOM {all_or_none} FILTER FOR {tag_names}'
>>> tag_filters = tagmgr.create_tag_filter(tags,
... name_format=fname,
... exclude=True)
[<Autodesk.Revit.DB.ParameterFilterElement object at ...>,
<Autodesk.Revit.DB.ParameterFilterElement object at ...>]
"""
sfilters = []
# create filter name and check availability
tags_col = join_tags(tags)
if not name_format:
name_format = tagscfg.TAG_FILTER_NAMING
filter_name = name_format.format(all_or_none='NONE' if exclude else 'ALL',
tag_names=tags_col.names)
for exst_filter in revit.query.get_rule_filters():
if exst_filter.Name == filter_name:
sfilters.append(exst_filter)
return sfilters
# get tags param id
param_id = _get_tag_paramid()
# create filter rule
if HOST_APP.is_newer_than(2019, or_equal=True):
rules = None
else:
rules = framework.List[DB.FilterRule]()
param_prov = DB.ParameterValueProvider(param_id)
param_contains = DB.FilterStringContains()
for tag in tags:
rule = DB.FilterStringRule(param_prov,
param_contains,
tag.name,
False)
if exclude:
rule = DB.FilterInverseRule(rule)
if HOST_APP.is_newer_than(2019, or_equal=True):
if rules:
rules = DB.LogicalOrFilter(rules,
DB.ElementParameterFilter(rule))
else:
rules = DB.ElementParameterFilter(rule)
else:
rules.Add(rule)
# collect applicable categories
cats = []
for cat in revit.query.get_all_category_set():
if DB.ParameterFilterElement.AllRuleParametersApplicable(
revit.doc,
framework.List[DB.ElementId]([cat.Id]),
rules
):
cats.append(cat.Id)
# create filter
sfilter = \
DB.ParameterFilterElement.Create(revit.doc,
filter_name,
framework.List[DB.ElementId](cats),
rules)
sfilters.append(sfilter)
return sfilters
fam_names = []
type_names = []
for lc in legend_components:
component_name = lc.get_Parameter(
DB.BuiltInParameter.LEGEND_COMPONENT).AsValueString()
fragments = component_name.split(" : ")
fam_names.append(fragments[1])
type_names.append(fragments[-1])
# find types of family and type
types_on_legend = []
for f, t in izip(fam_names, type_names):
fam_bip_id = DB.ElementId(DB.BuiltInParameter.SYMBOL_FAMILY_NAME_PARAM)
fam_bip_provider = DB.ParameterValueProvider(fam_bip_id)
fam_filter_rule = DB.FilterStringRule(fam_bip_provider,
DB.FilterStringEquals(), f, True)
fam_filter = DB.ElementParameterFilter(fam_filter_rule)
type_bip_id = DB.ElementId(DB.BuiltInParameter.ALL_MODEL_TYPE_NAME)
type_bip_provider = DB.ParameterValueProvider(type_bip_id)
type_filter_rule = DB.FilterStringRule(type_bip_provider,
DB.FilterStringEquals(), t, True)
type_filter = DB.ElementParameterFilter(type_filter_rule)
and_filter = DB.LogicalAndFilter(fam_filter, type_filter)
collector = DB.FilteredElementCollector(revit.doc) \
.WherePasses(and_filter) \
.WhereElementIsElementType() \
.FirstElement()
assetElem = revit.doc.GetElement(
selected_mat.AppearanceAssetId)
assetName = mat.pop("Asset Name")
duplicate_asset = assetElem.Duplicate(assetName.lower())
new_mat.AppearanceAssetId = duplicate_asset.Id
schema_name = mat.pop("Base Schema")
else:
message = (
'"%s" already exists. Attempting to edit parameters' %
mat_name)
logger.warning(message)
# If it already exists, collect it and modify it
namePar = DB.ParameterValueProvider(
DB.ElementId(DB.BuiltInParameter.MATERIAL_NAME))
fRule = DB.FilterStringRule(namePar,
DB.FilterStringEquals(),
mat_name, True)
filter = DB.ElementParameterFilter(fRule)
new_mat = (DB.FilteredElementCollector(revit.doc).OfClass(
DB.Material).WherePasses(filter).FirstElement())
assetElem = revit.doc.GetElement(new_mat.AppearanceAssetId)
schema_name = assetElem.GetRenderingAsset().Name
del mat["Base Schema"]
# ----- IDENTITY TAB -----
# Description
mat_description = mat.pop("Description")
if mat_description:
description = new_mat.get_Parameter(
DB.BuiltInParameter.ALL_MODEL_DESCRIPTION)
description.Set(mat_description)
