def calc_param_total(element_list, param_name):
sum_total = 0.0
def _add_total(total, param):
if param.StorageType == StorageType.Double:
total += param.AsDouble()
elif param.StorageType == StorageType.Integer:
total += param.AsInteger()
return total
for el in element_list:
param = el.LookupParameter(param_name)
if not param:
el_type = doc.GetElement(el.GetTypeId())
type_param = el_type.LookupParameter(param_name)
if not type_param:
logger.error('Elemend with ID: {} '
'does not have parameter: {}.'.format(el.Id,
param_name))
else:
sum_total = _add_total(sum_total, type_param)
else:
sum_total = _add_total(sum_total, param)
return sum_total
def _read_log_file(self, file_path):
entry_list = []
log_file_line = 1
prev_entry = None
try:
with open(file_path, 'r') as log_file:
for log_entry in log_file.readlines():
try:
new_entry = LogMessageListItem(log_entry)
entry_list.append(new_entry)
log_file_line += 1
prev_entry = new_entry
except Exception as err:
logger.debug('Error processing entry at {}:{}'.format(
op.basename(file_path), log_file_line))
prev_entry.message += log_entry
log_file_line += 1
except Exception as read_err:
logger.error('Error reading log file: {} | {}'.format(
file_path, read_err))
return entry_list
def __init__(self, xaml_file_name, selected_elements):
is_geom_list, not_geom_list = self.separate_geometry(selected_elements)
self.selection, self.is_geom = self.filter_geometry_and_other(is_geom_list, not_geom_list)
self.extra_geom_keys = [
# "<Along curve>",
"<X coordinate>",
"<Y coordinate>",
"<Z coordinate>"
]
if not self.selection:
logger.error("Selection error or wrong elements were selected")
return
parameters_dict = self.get_selection_parameters(self.selection)
self.parameters_sortable = self.filter_sortable(self.selection, parameters_dict)
self.parameters_editable = self.filter_editable(parameters_dict)
WPFWindow.__init__(self, xaml_file_name)
self._set_comboboxes()
self.read_config()
total_view_count = len(drafting_views)
for src_view in drafting_views:
this_script.output.print_md('-----\n**{} of {}**'.format(
view_count, total_view_count))
this_script.output.print_md('**Converting: {}**'.format(
src_view.ViewName))
dest_view_successfully_setup = False
try:
dest_view = create_dest_view(dest_view_type, src_view.ViewName,
src_view.Scale)
print('View created: {}'.format(dest_view.ViewName))
dest_view_successfully_setup = True
except Exception as err:
logger.error(
'Error creating model view for: {}. Conversion unsuccessful. | {}'
.format(src_view.ViewName, err))
if dest_view_successfully_setup:
print('Copying 2D contents from {} to {}'.format(
this_script.output.linkify(src_view.Id),
this_script.output.linkify(dest_view.Id)))
el_count = copy_paste_elements_btwn_views(src_view, dest_view)
if el_count:
print('Conversion completed. {} elements were copied.\n\n'.
format(el_count))
successfully_converted += 1
else:
print('Conversion cancelled. No elements were copied.\n\n')
view_count += 1
def change_materials(reverse=False, datafile=None, limit=None):
mat_dict = {}
white_material_name = config_material()
materials_exceptions = config_exceptions()
ignore_transparent = config_ignore_transparent()
if os.path.exists(datafile):
logger.debug("Datafile found %s" % datafile)
if reverse == False:
logger.debug("New materials will be added")
f = open(datafile, 'r')
mat_dict = pl.load(f)
f.close()
else:
logger.debug("New datafile %s" % datafile)
cl = FilteredElementCollector(doc)
mats = list(
cl.OfCategory(BuiltInCategory.OST_Materials).
WhereElementIsNotElementType().ToElements())
try:
white_mat = filter(lambda x: x.Name == white_material_name, mats)[0]
except Exception as e:
logger.error("Material '%s' not found" % white_material_name)
logger.error(e)
return
white_mat_a = white_mat.AppearanceAssetId
logger.info("White material: %s\nAssetId: %d" %
(white_material_name, white_mat_a.IntegerValue))
t = Transaction(doc)
t.Start(__title__ + (" reverse" if reverse else ""))
if limit > 0:
mats = mats[:limit]
for m in mats:
m_name = m.Name
m_name_ignore = False
for r in materials_exceptions:
re_match = re.match(r, m_name, re.I)
if re_match:
m_name_ignore = True
break
if m_name_ignore:
logger.info("%s - ignore name" % m_name)
continue
if m.Transparency != 0 and ignore_transparent:
logger.info("%s - ignore transparency" % m_name)
continue
m_id = m.Id.IntegerValue
a_id = m.AppearanceAssetId.IntegerValue
if reverse == False:
if a_id != white_mat_a.IntegerValue:
mat_dict[m_id] = a_id
m.AppearanceAssetId = white_mat_a
logger.info("%s (%d, asset %d) changed to white" %
(m_name, m_id, a_id))
else:
logger.info("%s (%d) wasn't change" % (m_name, m_id))
else:
try:
_id = mat_dict[m_id]
m.AppearanceAssetId = ElementId(_id)
logger.info("%s (%d) changed to %d" % (m_name, m_id, _id))
except:
logger.info("%s (%d) not found or wasn't change" %
(m_name, m_id))
t.Commit()
if reverse == False:
f = open(datafile, 'w')
pl.dump(mat_dict, f)
f.close()
else:
backup_datafile(datafile)
print("Completed")
def copy_view(activedoc, source_view, dest_doc):
matching_view = find_matching_view(dest_doc, source_view)
if matching_view:
print('\t\t\tView/Sheet already exists in document.')
if OPTION_SET.op_update_exist_view_contents:
if not copy_view_contents(activedoc, source_view,
dest_doc, matching_view,
clear_contents=OPTION_SET.op_update_exist_view_contents):
logger.error('Could not copy view contents: {}'.format(source_view.Name))
return matching_view
logger.debug('Copying view: {}'.format(source_view.Name))
new_view = None
if source_view.ViewType == ViewType.DrawingSheet:
try:
logger.debug('Source view is a sheet. ' \
'Creating destination sheet.')
t = Transaction(dest_doc, 'Create Sheet')
t.Start()
new_view = ViewSheet.Create(dest_doc,
ElementId.InvalidElementId)
new_view.ViewName = source_view.ViewName
new_view.SheetNumber = source_view.SheetNumber
t.Commit()
except Exception as sheet_err:
logger.error('Error creating sheet. | {}'.format(sheet_err))
elif source_view.ViewType == ViewType.DraftingView:
try:
logger.debug('Source view is a drafting. ' \
'Creating destination drafting view.')
t = Transaction(dest_doc, 'Create Drafting View')
t.Start()
new_view = ViewDrafting.Create(dest_doc,
get_default_type(dest_doc,
ElementTypeGroup.ViewTypeDrafting))
new_view.ViewName = source_view.ViewName
new_view.Scale = source_view.Scale
t.Commit()
except Exception as sheet_err:
logger.error('Error creating drafting view. | {}'.format(sheet_err))
elif source_view.ViewType == ViewType.Legend:
try:
logger.debug('Source view is a legend. ' \
'Creating destination legend view.')
first_legend = find_first_legend(dest_doc)
if first_legend:
t = Transaction(dest_doc, 'Create Legend View')
t.Start()
new_view = dest_doc.GetElement(
first_legend.Duplicate(
ViewDuplicateOption.Duplicate))
new_view.ViewName = source_view.ViewName
new_view.Scale = source_view.Scale
t.Commit()
else:
logger.error('Destination document must have at least one ' \
'Legend view. Skipping legend.')
except Exception as sheet_err:
logger.error('Error creating drafting view. | {}'.format(sheet_err))
if new_view:
copy_view_contents(activedoc, source_view, dest_doc, new_view)
return new_view
for v in views:
try:
filters = v.GetFilters()
for flid in filters:
usedFiltersSet.add(flid.IntegerValue)
except:
continue
unusedFilters = allFilters - usedFiltersSet
if unusedFilters:
print('{} Filters have not been used and will be purged.'.format(
len(unusedFilters)))
t = Transaction(doc, 'Purge Unused Filters')
t.Start()
for flid in unusedFilters:
fl = doc.GetElement(ElementId(flid))
print('Purging Filter: {0}\t{1}'.format(fl.Id, fl.Name))
try:
doc.Delete(ElementId(flid))
except Exception as del_err:
logger.error('Error purging filter: {} | {}'.format(
fl.Name, del_err))
t.Commit()
else:
print('All filters are in use. No purging in necessary.')
def main():
cl = FilteredElementCollector(doc)
levels_all = cl.OfCategory(BuiltInCategory.OST_Levels
).WhereElementIsNotElementType().ToElements()
options = []
for l in levels_all:
cb = CheckBoxLevel(l)
options.append(cb)
if len(options) == 0:
print("Levels wasn't found")
return
selected1 = SelectFromList.show(options,
title='Select levels to delete',
width=300,
button_name='OK',
multiselect=True)
selected_levels1 = [c.level for c in selected1 if c.state == True]
if not selected_levels1:
print("Nothing selected")
return
options = [c for c in selected1 if c.state != True]
if len(options) == 0:
print("You selected all levels")
return
selected2 = SelectFromList.show(options,
title='Select target level',
width=300,
button_name='OK')
if not selected2:
print("Nothing selected")
return
selected_levels2 = [c.level for c in selected2]
target_level = selected_levels2[0]
errors = set()
changed = set()
for l in selected_levels1:
objects_to_change = []
t = Transaction(doc, "Check level " + l.Name)
t.Start()
elements = doc.Delete(l.Id)
t.RollBack()
errors_, changed_ = LevelChangePreselected(elements, target_level.Id)
errors = errors.union(set(errors_))
changed = changed.union(set(changed_))
if errors:
logger.error("Errors")
logger.error(",".join(list(errors)))
if changed:
print("\nChanged succesfully")
print(",".join(list(changed)))
else:
logger.error("No object were changed")
def parse(value, reduce_duplicates=False):
value = strip(value)
if not value:
logger.error("Text is empty")
return
value_lines = value.split("\n")
errors = []
ids_str = []
ids_element_ids = []
for v in range(len(value_lines)):
vl = value_lines[v]
vl = strip(vl)
if not vl:
continue
_id = None
try:
_id = int(vl)
except:
pass
if not _id:
m = re.search(r"(id|Код)\s+([0-9]{1,})[^0-9]*", vl)
try:
_id = int(str(m.group(2)))
except:
pass
if _id:
e_id = ElementId(_id)
ids_element_ids.append(e_id)
ids_str.append(str(_id))
else:
errors.append("%d: %s" % (v, vl))
if len(ids_element_ids) > 0:
print('%d elements selected:' % len(ids_element_ids))
elements_strs = []
if reduce_duplicates:
ids_element_ids = set(ids_element_ids)
ids_str = set(ids_str)
for idx, elid in enumerate(ids_element_ids):
elements_strs.append(output.linkify(elid))
print(",".join(elements_strs))
# # Copy ids to clipboard
# addtoclipboard(",".join(set(ids_str)))
# Select objects
ids_element_ids_list = List[ElementId](ids_element_ids)
selection = uidoc.Selection
selection.SetElementIds(ids_element_ids_list)
# Save selection
try:
f = open(datafile, 'w')
pl.dump(ids_str, f)
f.close()
except Exception as io_err:
logger.error('Error read/write to: {} | {}'.format(
datafile, io_err))
else:
print("No IDs were found")
if len(errors) > 0:
logger.error("Ids weren't found on lines: \n" + "\n".join(errors))
fam_symbol = selected_comp.Symbol.Family
else:
TaskDialog.Show(
'pyRevit', 'System families do not have external type definition.')
logger.debug(
'Cancelled. System families do not have external type definition.')
this_script.exit()
else:
TaskDialog.Show('pyRevit',
'At least one family instance must be selected.')
logger.debug('Cancelled. No elements selected.')
this_script.exit()
# verify family symbol is ready ----------------------------------------------------------------------------------------
if not fam_symbol:
logger.error('Can not load family symbol.')
this_script.exit()
else:
logger.debug('Family symbol aquired: {}'.format(fam_symbol))
# define a class for family types so they can be smartly sorted --------------------------------------------------------
class SmartSortableFamilyType:
def __init__(self, type_name):
self.type_name = type_name
self.sort_alphabetically = False
self.number_list = [int(x) for x in re.findall('\d+', self.type_name)]
if not self.number_list:
self.sort_alphabetically = True
def __str__(self):
"""Opens keynote source file used in this model."""
__author__ = 'Dan Mapes'
__contact__ = 'https://github.com/DMapes'
import os
from scriptutils import logger
from revitutils import doc
from Autodesk.Revit.DB import KeynoteTable, ModelPathUtils
kt = KeynoteTable.GetKeynoteTable(doc)
kt_ref = kt.GetExternalFileReference()
path = ModelPathUtils.ConvertModelPathToUserVisiblePath(
kt_ref.GetAbsolutePath())
if not path:
logger.error('No keynote file is assigned...File address is empty.')
else:
os.system('start notepad "{0}"'.format(path))
def log_error(el_type='', el_id=0, delete_err=None):
err_msg = str(delete_err).replace('\n', ' ').replace('\r', '')
logger.error('Error Removing Element with Id: {} Type: {} | {}'.format(
el_type, el_id, err_msg))
try:
fromStyle, toStyle = get_styles()
line_list = []
cl = FilteredElementCollector(doc)
elfilter = ElementMulticategoryFilter(List[BuiltInCategory]([BuiltInCategory.OST_Lines, BuiltInCategory.OST_SketchLines]))
detail_lines = cl.WherePasses(elfilter).WhereElementIsNotElementType().ToElements()
for detail_line in detail_lines:
if detail_line.LineStyle.Name == fromStyle.Name:
line_list.append(detail_line)
with Transaction(doc, 'Swap Line Styles') as t:
t.Start()
for line in line_list:
if line.Category.Name != '<Sketch>' and line.GroupId < ElementId(0):
line.LineStyle = toStyle
elif line.Category.Name == '<Sketch>':
line.LineStyle = toStyle
elif line.GroupId > ElementId(0):
logger.debug('Skipping grouped line: {} in group {}'.format(line.Id, line.GroupId))
# shake_filled_regions()
t.Commit()
except Exception as err:
logger.error(err)
def main():
location = doc.ActiveProjectLocation
activeview = uidoc.ActiveView
project_position = location.get_ProjectPosition(XYZ.Zero)
project_angle = project_position.Angle
origin = location.GetTotalTransform().Origin
# Search for any 3D view or a Plan view
cl = FilteredElementCollector(doc)
views = cl.OfCategory(
BuiltInCategory.OST_Views).WhereElementIsNotElementType().ToElements()
q = TaskDialog.Show(
__title__, "Link CAD to current view only?",
TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No
| TaskDialogCommonButtons.Cancel)
if str(q) == "No":
this_view_only = False
target_view = None
elif str(q) == "Yes":
this_view_only = True
target_view = activeview
else:
return
rotate = False
if not target_view:
target_view_project = None
target_view_3d = None
for v in views:
if v.IsTemplate:
continue
if type(v) == ViewPlan:
orientation = v.get_Parameter(BuiltInParameter.PLAN_VIEW_NORTH)
if orientation.AsInteger() == 1:
target_view = v
break
else:
if not target_view_project:
target_view_project = v
if type(v) == View3D and not target_view_3d:
target_view_3d = v
if not target_view:
rotate = True
if target_view_project:
target_view = target_view_project
elif target_view_3d:
target_view = target_view_3d
if not target_view:
logger.error(
"Please create 3D view or a PlanView in a project to place CAD correctly"
)
return
path = pick_file(
files_filter=
"DWG files (*.dwg)|*.dwg|DXF files (*.dxf)|*.dxf|DGN files (*.dgn)|*.dgn|All files (*.*)|*.*"
)
if not path:
return
o = DWGImportOptions()
o.AutoCorrectAlmostVHLines = False
o.Unit = ImportUnit.Meter
o.OrientToView = False
o.ReferencePoint = origin
o.ThisViewOnly = this_view_only
link_func = doc.Link.Overloads[str, DWGImportOptions, View,
System.Type.MakeByRefType(ElementId)]
t = Transaction(doc)
t.Start(__title__)
try:
status, e_id = link_func(
path,
o,
target_view,
)
except Exception as e:
logger.error("Unable to import CAD")
logger.error(e)
status = False
# override rotation option
if __shiftclick__:
q = TaskDialog.Show(
__title__, "Is it okay?\nIf not CAD will be rotated",
TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No
| TaskDialogCommonButtons.Cancel)
if str(q) == "No":
rotate = True
elif str(q) == "Yes":
rotate = False
else:
return
if status:
l = doc.GetElement(e_id)
if rotate:
if l.Pinned:
l.Pinned = False
axis = Line.CreateBound(origin,
XYZ(origin.X, origin.Y, origin.Z + 1))
ElementTransformUtils.RotateElement(doc, l.Id, axis,
-project_angle)
l.Pinned = True
t.Commit()
else:
t.RollBack()
from Autodesk.Revit.DB import Transaction, ViewSheet
shift = 1
selected_sheets = []
for sheet in selection.elements:
if isinstance(sheet, ViewSheet):
selected_sheets.append(sheet)
sorted_sheet_list = sorted(selected_sheets, key=lambda x: x.SheetNumber)
if shift >= 0:
sorted_sheet_list.reverse()
with Transaction(doc, 'Shift Sheets') as t:
t.Start()
for sheet in sorted_sheet_list:
try:
cur_sheet_num = sheet.SheetNumber
sheet_num_param = sheet.LookupParameter('Sheet Number')
sheet_num_param.Set(
coreutils.increment_str(sheet.SheetNumber, shift))
new_sheet_num = sheet.SheetNumber
logger.info('{} -> {}'.format(cur_sheet_num, new_sheet_num))
except Exception as shift_err:
logger.error(shift_err)
doc.Regenerate()
t.Commit()
def main():
allowed_types = [
ViewPlan,
View3D,
ViewSection,
ViewSheet,
ViewDrafting
]
selection = uidoc.Selection.GetElementIds()
if type(doc.ActiveView)!=View:
active_view = doc.ActiveView
else:
active_view = doc.GetElement(selection[0])
if type(active_view) not in allowed_types:
logger.error('Selected view is not allowed. Please select or open view from which you want to copy template settings VG Overrides - Filters')
return
logger.info('Source view selected: %s id%s' % (active_view.Name, active_view.Id.ToString()))
active_template = doc.GetElement(active_view.ViewTemplateId)
logger.info('Source template: %s id%s' % (active_template.Name, active_template.Id.ToString()))
active_template_filters = active_template.GetFilters()
# print(active_template_filter_rules)
# return
selset = read_states()
# print(selset)
vt_dict = get_view_templates(doc,selset=selset)
active_template_filters_ch = get_view_filters(doc,active_template)
all_checkboxes = SelectFromCheckBoxes.show(active_template_filters_ch)
sel_checkboxes_filter = []
# now you can check the state of checkboxes in your program
for checkbox in all_checkboxes:
if checkbox:
sel_checkboxes_filter.append(checkbox)
if len(sel_checkboxes_filter)==0:
return
all_checkboxes = SelectFromCheckBoxes.show(vt_dict)
sel_checkboxes = []
# now you can check the state of checkboxes in your program
for checkbox in all_checkboxes:
if checkbox:
sel_checkboxes.append(checkbox)
if len(sel_checkboxes)==0:
return
write_state(sel_checkboxes)
t = Transaction(doc)
t.Start("Copy VG")
for ch in sel_checkboxes:
vt = doc.GetElement(ch.id)
if vt.Id == active_template.Id:
print('current template found')
continue
for f in sel_checkboxes_filter:
fId = f.id
try:
vt.RemoveFilter(fId)
logger.info('filter %s deleted from template %s' % (fId.ToString(), vt.Name))
except:
pass
try:
fr = active_template.GetFilterOverrides(fId)
vt.SetFilterOverrides(fId,fr)
except Exception as e:
logger.warning('filter not aplied to active view %s\n%s' % (fId.ToString(), e))
t.Commit()
print("finished")