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")