def process_sets(element_list):
el_sets = DefaultOrderedDict(list)
# add all elements as first set, for totals of all elements
el_sets['All Selected Elements'].extend(element_list)
# separate elements into sets based on their type
for el in element_list:
if hasattr(el, 'LineStyle'):
el_sets[el.LineStyle.Name].append(el)
else:
eltype = revit.doc.GetElement(el.GetTypeId())
wrapped_eltype = revit.ElementWrapper(eltype)
el_sets[wrapped_eltype.name].append(el)
return el_sets
def removeallemptyelevationmarkers():
with revit.Transaction('Remove All Elevation Markers'):
print('REMOVING ELEVATION MARKERS...\n')
elevmarkers = DB.FilteredElementCollector(revit.doc)\
.OfClass(DB.ElevationMarker)\
.WhereElementIsNotElementType()\
.ToElements()
for em in elevmarkers:
if em.CurrentViewCount == 0:
emtype = revit.doc.GetElement(em.GetTypeId())
print('ID: {0}\tELEVATION TYPE: {1}'
.format(em.Id,
revit.ElementWrapper(emtype).name))
try:
revit.doc.Delete(em.Id)
except Exception as e:
logger.error('Error removing marker: {} | {}'
.format(em.Id, e))
continue
def _ask_for_titleblock(self):
no_tb_option = 'No Title Block'
titleblocks = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_TitleBlocks)\
.WhereElementIsElementType()\
.ToElements()
tblock_dict = {
'{}: {}'.format(tb.FamilyName,
revit.ElementWrapper(tb).name): tb
for tb in titleblocks
}
options = [no_tb_option]
options.extend(tblock_dict.keys())
selected_titleblocks = forms.SelectFromList.show(options,
multiselect=False)
if selected_titleblocks:
if no_tb_option not in selected_titleblocks:
self._titleblock_id = tblock_dict[selected_titleblocks[0]].Id
else:
self._titleblock_id = DB.ElementId.InvalidElementId
return True
return False
revit.doc.GetElement(v.ViewId).ViewName))
elif selected_switch == 'Element Types':
all_types = \
revit.query.get_types_by_class(DB.ElementType, doc=revit.doc)
etypes_dict = defaultdict(list)
for etype in all_types:
if etype.FamilyName:
etypes_dict[str(etype.FamilyName).strip()].append(etype)
for etype_name in sorted(etypes_dict.keys()):
etypes = etypes_dict[etype_name]
output.print_md('**{}**'.format(etype_name))
for et in etypes:
print('\t{} {}'.format(output.linkify(et.Id),
revit.ElementWrapper(et).name))
elif selected_switch == 'Family Symbols':
cl = DB.FilteredElementCollector(revit.doc)
eltype_list = cl.OfClass(DB.ElementType).ToElements()
for et in eltype_list:
wrapperd_et = revit.ElementWrapper(et)
print(wrapperd_et.name, et.FamilyName)
elif selected_switch == 'Levels':
levelslist = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_Levels)\
.WhereElementIsNotElementType()
for i in levelslist:
def __hash__(self):
return hash(self.type_name)
def __lt__(self, other):
if self.sort_alphabetically or other.sort_alphabetically:
return self.type_name < other.type_name
else:
return self.number_list < other.number_list
# collect all symbols already loaded
loaded_symbols = set()
for sym_id in fam_symbol.GetFamilySymbolIds():
fam_sym = revit.doc.GetElement(sym_id)
fam_sym_name = revit.ElementWrapper(fam_sym).name
sortable_sym = SmartSortableFamilyType(fam_sym_name)
logger.debug('Loaded Type: {}'.format(sortable_sym))
loaded_symbols.add(sortable_sym)
# get family document and verify the file exists
fam_doc = revit.doc.EditFamily(fam_symbol)
fam_doc_path = fam_doc.PathName
if not op.exists(fam_doc_path):
forms.alert(
'Can not file original family file at\n{}'.format(fam_doc_path))
logger.debug(
'Can not file original family file at {}'.format(fam_doc_path))
script.exit()
else:
logger.debug('Loading family from: {}'.format(fam_doc_path))
"""Get a total count and types of parking elements in the current view."""
from pyrevit.framework import List
from pyrevit import revit, DB
parkings = DB.FilteredElementCollector(revit.doc, revit.activeview.Id)\
.OfCategory(DB.BuiltInCategory.OST_Parking)\
.WhereElementIsNotElementType()\
.ToElementIds()
print('PARKING COUNT: {0}'.format(len(list(parkings))))
ptypesdic = {}
for pid in parkings:
ptype = revit.doc.GetElement(revit.doc.GetElement(pid).GetTypeId())
wrapped_ptype = revit.ElementWrapper(ptype)
ptname = wrapped_ptype.name
if ptname in ptypesdic:
ptypesdic[ptname] += 1
else:
ptypesdic[ptname] = 1
print('PARKING TYPES AND COUNTS')
for ptname, ptcount in ptypesdic.items():
print('TYPE: {0}COUNT: {1}'.format(ptname.ljust(35), ptcount))
# Print Title and Report Info
console.print_md('# {}'.format(report_title))
print('Project Name: {project}\nDate: {date}'.format(project=report_project,
date=report_date))
console.insert_divider()
# Print information about all existing revisions
console.print_md('### List of Revisions')
# prepare markdown code for the revision table
rev_table_header = "| Number | Date | Description |\n" \
"|:-------------:|:--------------:|:-------------|\n"
rev_table_template = "|{number}|{date}|{desc}|\n"
rev_table = rev_table_header
for rev in all_revisions:
wrev = revit.ElementWrapper(rev)
revnum = wrev.safe_get_param('RevisionNumber', rev.SequenceNumber)
rev_table += rev_table_template.format(number=revnum,
date=rev.RevisionDate,
desc=rev.Description)
# print revision table
console.print_md(rev_table)
class RevisedSheet:
def __init__(self, rvt_sheet):
self._rvt_sheet = rvt_sheet
self._find_all_clouds()
self._find_all_revisions()
.WhereElementIsNotElementType().ToElements()
for v in vps:
print('ID: {1}TYPE: {0}VIEWNAME: {2}'.format(
v.Name.ljust(30),
str(v.Id).ljust(10),
revit.doc.GetElement(v.ViewId).ViewName))
elif selected_switch == 'Viewport Types':
vps = []
cl_views = DB.FilteredElementCollector(revit.doc)
vptypes = cl_views.OfClass(DB.ElementType).ToElements()
for tp in vptypes:
wrapperd_tp = revit.ElementWrapper(tp)
if tp.FamilyName == 'Viewport':
print('ID: {1} TYPE: {0}'.format(wrapperd_tp.name,
str(tp.Id).ljust(10)))
elif selected_switch == 'Family Symbols':
cl = DB.FilteredElementCollector(revit.doc)
eltype_list = cl.OfClass(DB.ElementType).ToElements()
for et in eltype_list:
wrapperd_et = revit.ElementWrapper(et)
print(wrapperd_et.name, et.FamilyName)
elif selected_switch == 'Levels':
levelslist = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_Levels)\
def __str__(self):
return revit.ElementWrapper(self._rvt_type).name
from pyrevit import script, revit
__context__ = 'selection'
__doc__ = 'Lists the selected element ids as clickable links. '\
'This is a quick way to go through a series of elements.'
output = script.get_output()
selection = revit.get_selection()
if len(selection.element_ids) > 0:
output.set_width(300)
if len(selection.element_ids) < 50:
print('{}'.format(
output.linkify(selection.element_ids, title='All Elements')))
for idx, element in enumerate(selection.elements):
print('{}: {} {}'.format(idx + 1, output.linkify(element.Id),
revit.ElementWrapper(element).name))
from pyrevit import revit, DB
from pyrevit import script
__beta__ = True
logger = script.get_logger()
# make sure active document is a family
forms.check_familydoc(exitscript=True)
selection = revit.get_selection()
cad_import = selection.first
cad_trans = cad_import.GetTransform()
cad_type = cad_import.Document.GetElement(cad_import.GetTypeId())
cad_name = revit.ElementWrapper(cad_type).name
family_cat = revit.doc.OwnerFamily.FamilyCategory
geo_elem = cad_import.get_Geometry(DB.Options())
geo_elements = []
for geo in geo_elem:
logger.debug(geo)
if isinstance(geo, DB.GeometryInstance):
geo_elements.extend([x for x in geo.GetSymbolGeometry()])
solids = []
for gel in geo_elements:
logger.debug(gel)
if isinstance(gel, DB.Solid):
# if hasattr(gel, 'Volume') and gel.Volume > 0.0:
__context__ = 'selection'
selection = revit.get_selection()
grps = list(DB.FilteredElementCollector(revit.doc)
.OfClass(framework.get_type(DB.Group))
.ToElements())
grpTypes = set()
if len(selection) > 0:
for el in selection:
if isinstance(el, DB.Group):
selectedgtid = el.GroupType.Id
for g in grps:
mems = g.GetMemberIds()
for memid in mems:
mem = revit.doc.GetElement(memid)
if isinstance(mem, DB.Group):
memgtid = mem.GroupType.Id
if memgtid == selectedgtid:
grpTypes.add(g.GroupType.Id)
for gtId in grpTypes:
wrapped_gtype = \
revit.ElementWrapper(revit.doc.GetElement(gtId))
print(wrapped_gtype.name)
selected_option = \
forms.CommandSwitchWindow.show(all_options,
message='Pick type category:')
if selected_option:
selection = revit.get_selection()
if selected_option == 'Fill Patterns':
fill_patterns = revit.query.get_types_by_class(DB.FillPatternElement,
doc=revit.doc)
selection.set_to(list(fill_patterns))
if selected_option == 'Area Schemes':
area_schemes = revit.query.get_types_by_class(DB.AreaScheme,
doc=revit.doc)
selection.set_to(list(area_schemes))
elif selected_option.startswith('Graphics Styles: '):
graphic_style_cat = selected_option.replace('Graphics Styles: ', '')
graphic_styles = \
[x for x in revit.query.get_types_by_class(DB.GraphicsStyle,
doc=revit.doc)
if x.GraphicsStyleCategory
and x.GraphicsStyleCategory.CategoryType != DB.CategoryType.Internal
and graphic_style_cat == x.GraphicsStyleCategory.Name]
selection.set_to(list(graphic_styles))
else:
all_types = \
revit.query.get_types_by_class(DB.ElementType, doc=revit.doc)
selection.set_to([
x for x in all_types if selected_option == x.FamilyName
and revit.ElementWrapper(x).name != x.FamilyName
])
.WhereElementIsNotElementType().ToElements()
for v in vps:
print('ID: {1}TYPE: {0}VIEWNAME: {2}'
.format(v.Name.ljust(30),
str(v.Id).ljust(10),
revit.doc.GetElement(v.ViewId).ViewName))
elif selected_switch == 'Viewport Types':
vps = []
cl_views = DB.FilteredElementCollector(revit.doc)
vptypes = cl_views.OfClass(DB.ElementType).ToElements()
for tp in vptypes:
wrapperd_tp = revit.ElementWrapper(tp)
if tp.FamilyName == 'Viewport':
print('ID: {1} TYPE: {0}'.format(wrapperd_tp.name,
str(tp.Id).ljust(10)))
elif selected_switch == 'Family Symbols':
cl = DB.FilteredElementCollector(revit.doc)
eltype_list = cl.OfClass(DB.ElementType).ToElements()
for et in eltype_list:
wrapperd_et = revit.ElementWrapper(et)
print(wrapperd_et.name, et.FamilyName)
elif selected_switch == 'Levels':
levelslist = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_Levels)\
def __repr__(self):
return '<{} Name:{} Id:{}>'\
.format(self.__class__.__name__,
revit.ElementWrapper(self._rvt_type).name,
self._rvt_type.Id.IntegerValue)
def _get_linked_model_doc(self):
linked_model = self.linkedmodels_lb.SelectedItem
for open_doc in revit.docs:
if open_doc.Title == revit.ElementWrapper(linked_model).name:
return open_doc
DB.Line.CreateBound(
DB.XYZ(base_point.X + 1, base_point.Y, base_point.Z),
DB.XYZ(base_point.X + 1, base_point.Y + DIRECTION, base_point.Z)))
cloop.Append(
DB.Line.CreateBound(
DB.XYZ(base_point.X + 1, base_point.Y + DIRECTION, base_point.Z),
DB.XYZ(base_point.X, base_point.Y + DIRECTION, base_point.Z)))
cloop.Append(
DB.Line.CreateBound(
DB.XYZ(base_point.X, base_point.Y + DIRECTION, base_point.Z),
DB.XYZ(base_point.X, base_point.Y, base_point.Z)))
DB.FilledRegion.Create(revit.doc, fr_type.Id, revit.activeview.Id,
List[DB.CurveLoop]([cloop]))
def make_swatch(index, fr_type):
row = 0 + (index / MAX_WIDTH)
col = index - (MAX_WIDTH * row)
base_point = DB.XYZ(col, row * DIRECTION, 0)
make_title(base_point, fr_type)
make_filledregion_element(base_point, fr_type)
filledregion_types = revit.query.get_types_by_class(DB.FilledRegionType)
with revit.Transaction('Generate FilledRegion Swatched'):
for idx, filledregion_type in enumerate(
sorted(filledregion_types,
key=lambda x: revit.ElementWrapper(x).name)):
make_swatch(idx, filledregion_type)
