def platics(self):
"""
Платики.
Ищем платики данной панели.
"""
if not hasattr(self, "_platics"):
bb = self.union_solid.GetBoundingBox()
tt = bb.Transform
p1 = tt.OfPoint(bb.Min)
p2 = tt.OfPoint(bb.Max)
outline = Outline(p1, p2)
filtered = BoundingBoxIntersectsFilter(outline)
collector = FilteredElementCollector(self.doc).OfCategory(
BuiltInCategory.OST_StructConnections).WherePasses(filtered)
collector = collector.ToElements()
res = []
for i in collector:
param = i.LookupParameter(self.element_type_parameter_name)
param = i.Symbol.LookupParameter(
self.element_type_parameter_name
) if param is None else param
if param and param.AsDouble() == self.platic_parameter_value:
res.append(Precast_unit_member(i, self.doc, self))
self._platics = res
return self._platics
def delete_spaces(self):
'''
Function deletes spaces
'''
self.counter = 0
space_collector = FilteredElementCollector(
self.doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_MEPSpaces)
spaces = space_collector.ToElements()
self.startProgress.emit(len(spaces))
with Transaction(self.doc, "Delete spaces") as tr:
tr.Start()
for space in spaces:
try:
self.doc.Delete(space.Id)
self.counter += 1
self.ReportProgress.emit(self.counter)
except Exception as e:
logger.error(e, exc_info=True)
pass
tr.Commit()
self.New_MEPSpaces = {}
self.Exist_MEPSpaces = {}
self.endProgress.emit()
def jt_getWallTypesDictionary():
wfec = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_Walls).WhereElementIsElementType()
wtd = {}
wtypes = wfec.ToElements()
for wt in wtypes:
wtd[jt_GetName(wt)] = wt
return wtd
def panels(self):
"""
Поиск панелей.
Если выбран элемент.
Выбираем у него все, что вложено
Если не выбран - берем все элементы категории стены и колонны.
Проходим по всем элементам.
Если является эеземпляром семейства, не системное.
Идем дальше.
Проверяем является ли семейство геометрическое:
Должен быть префикс 215
216 префикс у контейнеров
Проверяем является ли семейство параметрическим.
Префикс 214
Если семейство геометрическое, либо параметрическое, добавляем
в _panels экземпляр класса Precast_panel.
с параметром geometrical говорящее. является ли элемент
геометрическим.
Так же прокидываем нужно ли анализировать геометрию.
Если нет - будет выполнено только объединение и заполнение параметров.
См. класс Precast_panel
"""
if not hasattr(self, "_panels"):
self._panels = []
sel_id = self.uidoc.Selection.GetElementIds()
if not sel_id.Count:
wall_panels = FilteredElementCollector(self.doc).OfCategory(
BuiltInCategory.OST_Walls).WhereElementIsElementType()
wall_panels.UnionWith(FilteredElementCollector(
self.doc).OfCategory(BuiltInCategory.OST_Columns).WhereElementIsNotElementType())
wall_panels = wall_panels.ToElements()
else:
sel_elements = [self.doc.GetElement(
i) for i in self.uidoc.Selection.GetElementIds()]
wall_panels = []
for i in sel_elements:
if isinstance(i, AssemblyInstance):
wall_panels += [self.doc.GetElement(j) for j in i.GetMemberIds()]
else:
wall_panels.append(i)
wall_panels += [self.doc.GetElement(k) for j in wall_panels for k in j.GetSubComponentIds()]
for i in wall_panels:
if isinstance(i, FamilyInstance):
geometrical = i.Symbol.Family.Name[:len(
self.panel_prefix)] == self.panel_prefix
parametrical = i.Symbol.Family.Name[:len(
self.panel_parametrical_prefix)] == self.panel_parametrical_prefix
if geometrical or parametrical:
self._panels.append(Precast_panel(
i, doc=self.doc, analys_geometry=self.analys_geometry, geometrical=geometrical))
return self._panels
def process(datafile, saved_list=[], reverse=False):
if not reverse:
cl = FilteredElementCollector(
doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_Constraints)
constraints = cl.ToElements()
constraints_to_change = filter(lambda c: c.NumberOfSegments == 0,
constraints)
constraints_to_change = list(
filter(lambda c: c.IsLocked, constraints_to_change))
td_text = "%d enabled Constraints found. Disable them?" % len(
constraints_to_change)
else:
td_text = "Reverse mode.\n%d saved Constraints found. Recover them?" % len(
saved_list)
constraints_to_change = []
for id_int in saved_list:
try:
element = doc.GetElement(ElementId(id_int))
constraints_to_change.append(element)
except:
pass
tdres = TaskDialog.Show(
"Constraints", td_text,
TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No)
if tdres == TaskDialogResult.No:
return
t = Transaction(doc, __title__)
t.Start()
is_error = False
try:
for constraint in constraints_to_change:
constraint.IsLocked = True if reverse else False
if not reverse:
saved_list.append(constraint.Id.IntegerValue)
except Exception as exc:
is_error = True
t.RollBack()
TaskDialog.Show(__title__, "Error. Changes cancelled.")
else:
t.Commit()
result_text = "Finished."
if not reverse:
result_text += "\nChanged elements saved. To recover then run the same script with SHIFT button"
TaskDialog.Show(__title__, result_text)
if not is_error:
save(datafile, saved_list)
selection.set_to(map(lambda e: e.Id, constraints_to_change))
def get_all_wall_curves():
wfec = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_Walls).WhereElementIsNotElementType()
walls = wfec.ToElements()
swfec = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_StackedWalls).WhereElementIsNotElementType()
swalls = swfec.ToElements()
wtd = jt_getWallTypesDictionary()
stacked = []
walltypes = []
print ' -- Stacked--', len(swalls)
for w in swfec:
if jt_GetName(w.WallType) not in stacked:
stacked.append(jt_GetName(w.WallType))
print stacked
print ' -- Other--', len(walls)
for w in walls:
if jt_GetName(w.WallType) not in walltypes:
walltypes.append(jt_GetName(w.WallType))
print walltypes
for x in swalls:
jt_getWallCurve(x)
def get_elems_by_builtinCategory(cls,
built_in_cat=None,
include=[],
active_view=None):
"""Получение элемента по встроенному классу."""
if not include:
if not active_view:
els = FilteredElementCollector(doc).OfCategory(built_in_cat)
else:
els = FilteredElementCollector(doc, active_view).\
OfCategory(built_in_cat)
return els.ToElements()
if include:
new_list = []
for i in include:
if not active_view:
els = FilteredElementCollector(doc).OfCategory(
built_in_cat)
else:
els = FilteredElementCollector(doc, active_view).\
OfCategory(built_in_cat)
new_list += els.ToElements()
return new_list
def structural_framing(self):
if not hasattr(self, "_structural_framing"):
eror_elements = []
self._structural_framing = []
for doc, count in self.docs.items():
fec = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_StructuralFraming).WhereElementIsNotElementType()
for el in fec.ToElements():
par = self.get_parameter(el, par_names["КлассЧисло"])
if par and par.AsDouble():
new_el = StructuralFraming(el, self.csv_dict, count=count)
if not new_el.error:
self._structural_framing.append(new_el)
else:
eror_elements.append(new_el)
if len(eror_elements):
echo("Ошибочные элементы в проекте в количестве {}.".format(len(eror_elements)))
for i in eror_elements:
echo(i.error, " ", i.doc_name())
return self._structural_framing
import clr
clr.AddReference('RevitAPI')
clr.AddReference('RevitServices')
# Revit and Dynamo module
from Autodesk.Revit.DB import FilteredElementCollector, Family
from RevitServices.Persistence import DocumentManager
doc = DocumentManager.Instance.CurrentDBDocument
# argument assigned the IN port
elements = IN[0]
# wrap input inside a list (if not a list)
if not isinstance(elements, list):
elements = [elements]
# get family_type from family
family_type = []
collector = FilteredElementCollector(doc).OfClass(Family)
for element in collector.ToElements():
if element.Name in elements:
t = []
for family_type_id in element.GetFamilySymbolIds():
t.append(doc.GetElement(family_type_id))
family_type.append(t)
# return assigned the OUT port
OUT = SingleOut(family_type)
# all_sections = list(all_sections)
all_sections = list(all_sections_with_levels.keys())
for i in all_sections_with_levels.keys():
all_sections_with_levels[i] = list(all_sections_with_levels[i])
all_sections_with_levels[i].sort()
# all_levels.sort()
all_sections.sort(reverse=True)
# echo(all_sections_with_levels)
tags = {}
# echo(all_sections)
for link_doc, sections in all_docs.items():
sections_num = sections.keys()
panels = FilteredElementCollector(link_doc).OfCategory(BuiltInCategory.OST_Walls).OfClass(FamilyInstance)
# panels.UnionWith(FilteredElementCollector(link_doc).OfCategory(BuiltInCategory.OST_Columns).OfClass(FamilyInstance))
panels = panels.ToElements()
panels = [i for i in panels if i.Symbol.Family.Name[:len(panel_prefix)] == panel_prefix or i.Symbol.Family.Name[:len(panel_prefix_parametrical)] == panel_prefix_parametrical]
for panel in panels:
# echo(link_doc.Title)
symb = panel.Symbol
tag = ""
pref_tag = symb.LookupParameter("BDS_MarkPrefix")
if pref_tag:
tag += pref_tag.AsString()
fas_tag = panel.Symbol.LookupParameter("BDS_FacadeType")
if fas_tag:
tag += fas_tag.AsString()
sub_tag = panel.Symbol.LookupParameter("BDS_MarkSubPrefix")
if sub_tag and sub_tag.AsString():
tag += "-" + sub_tag.AsString()
tag_par = panel.LookupParameter("BDS_Tag")
""""
FilteredElementCollector Class
http://www.revitapidocs.com/2018/263cf06b-98be-6f91-c4da-fb47d01688f3.htm
public FilteredElementCollector(
Document document
)
Usage:
>>> FilteredElementCollector collector = new FilteredElementCollector(doc);
>>> walls = collector.OfClass(Wall).ToElements()
"""
from Autodesk.Revit.DB import FilteredElementCollector, Wall
collector = FilteredElementCollector(doc)
walls = collector.ToElements()
""""
Line Intersect Method (Users Out/Ref Values)
http://www.revitapidocs.com/2018/51961478-fb36-e00b-2d1b-7db27b0a09e6.htm
public SetComparisonResult Intersect(
Curve curve,
out IntersectionResultArray resultArray
)
Usage:
>>> IntersectionResultArray results;
>>> SetComparisonResult result = line1.Intersect( line2, out results );
>>> if( result != SetComparisonResult.Overlap ) {
# from Autodesk.Revit.UI import *
from Autodesk.Revit.DB import FilteredElementCollector, BuiltInCategory, View # don't need to import that
from System.Collections.Generic import List
import sys
pyt_path = (r'C:\Program Files (x86)\IronPython 2.7\Lib')
sys.path.append(pyt_path)
doc = __revit__.ActiveUIDocument.Document
####### FILTERED ELEMENT COLLECTOR #####################################################
# --- create Instance of FEC, Collect all OST_Lines
alllines = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Lines)
alllines.ToElements()
# Filter for Name: "HK" (Hilfskonstruktion) : list comprehension
hklines = [x for x in alllines if x.LineStyle.Name == "HK"]
# --- FEC for Text -----------------------------------------
txtcol = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_TextNotes).ToElements()
hktxt = [x for x in txtcol if x.Name.Contains("HK")]
# FEC Dimension witch contains "HK" string -----------------------------------
dimcol = FilteredElementCollector(doc).OfCategory(
BuiltInCategory.OST_Dimensions).ToElements()
hkdim = [x for x in dimcol if x.Name.Contains("HK")]
#----- FilteredElementCollector of Views , Create Instance of FEC, ----------------------------
viewcol = FilteredElementCollector(doc).OfClass(View).ToElements()
class Model(object):
def __init__(self,
__revit__,
search_id=None,
excel_parameters=None,
xl_file_path=None,
xl_write_flag=False):
# region Get Document and Application
self.doc = __revit__.ActiveUIDocument.Document
self.uidoc = UIDocument(self.doc)
self.app = __revit__.Application
self.uiapp = UIApplication(self.app)
self.excel = Excel.ApplicationClass()
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo(
"en-US")
# endregion
# region Initial parameters
self._search_id = search_id
self._excel_parameters = excel_parameters
self._xl_file_path = xl_file_path
self._xl_write_flag = xl_write_flag
self.New_MEPSpaces = {}
self.Exist_MEPSpaces = {}
# Create a space collector instance
self._space_collector = FilteredElementCollector(
self.doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_MEPSpaces)
# endregion
# region Custom Events
self.startProgress = Event()
self.ReportProgress = Event()
self.endProgress = Event()
# endregion
# region Getters and Setters
@property
def search_id(self):
return self._search_id
@search_id.setter
def search_id(self, value):
self._search_id = value
@property
def xl_file_path(self):
return self._xl_file_path
@xl_file_path.setter
def xl_file_path(self, value):
self._xl_file_path = value
@property
def xl_write_flag(self):
return self._xl_write_flag
@xl_write_flag.setter
def xl_write_flag(self, value):
self._xl_write_flag = value
@property
def excel_parameters(self):
return self._excel_parameters
@excel_parameters.setter
def excel_parameters(self, par_list):
self._excel_parameters = par_list
@property
def spaces_count(self):
self._spaces_count = self._space_collector.GetElementCount()
return self._spaces_count
# endregion Getters and Setters
def main(self):
# Create a selection
sel = self.uidoc.Selection
# Prompt the user to pick the required external link
try:
ref = sel.PickObject(ObjectType.Element,
"Please pick a linked model instance")
# Get AR RVT link
rvt_link = self.doc.GetElement(ref.ElementId)
if not self.rvt_link_check(rvt_link):
WinForms.MessageBox.Show("The operation was cancelled!",
"Error!",
WinForms.MessageBoxButtons.OK,
WinForms.MessageBoxIcon.Information)
return
self.transform = rvt_link.GetTotalTransform()
linkedDoc = rvt_link.GetLinkDocument()
# Create a room collector instance
room_collector = FilteredElementCollector(linkedDoc)
# Create a space collector instance
self._space_collector = FilteredElementCollector(
self.doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_MEPSpaces)
# Collect levels from the current document
levels = FilteredElementCollector(
self.doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_Levels)
# For each level in the current model define its elevation and create level elevation:Level dictionary
self.lvls_dict = {level.Elevation: level for level in levels}
# Collect rooms from RVT link
if room_collector and room_collector.GetElementCount() != 0:
self.rooms_list = room_collector.WhereElementIsNotElementType(
).OfCategory(BuiltInCategory.OST_Rooms)
self.counter = 0
self.startProgress.emit(room_collector.GetElementCount() + self.spaces_count + \
(2*(room_collector.GetElementCount()*len(self._excel_parameters))))
self.__main()
self.endProgress.emit()
except Exception as e:
logger.error(e, exc_info=True)
WinForms.MessageBox.Show("The operation was cancelled!", "Error!",
WinForms.MessageBoxButtons.OK,
WinForms.MessageBoxIcon.Information)
return
def __main(self):
try:
# Create spaces by rooms
self.create_spaces_by_rooms(self.rooms_list)
# Write data to an excel file
if self._xl_write_flag:
self.__write_to_excel(self._excel_parameters)
except Exception as e:
logger.error(e, exc_info=True)
pass
def rvt_link_check(self, rvt_link_instance):
rvt_link_type = self.doc.GetElement(rvt_link_instance.GetTypeId())
try:
room_bound = rvt_link_type.get_Parameter(
BuiltInParameter.WALL_ATTR_ROOM_BOUNDING)
if not room_bound.AsInteger():
result = WinForms.MessageBox.Show(
"Room Bounding is turned off! Would you like to turn it on?",
"Warning!", WinForms.MessageBoxButtons.YesNo,
WinForms.MessageBoxIcon.Question)
if result == WinForms.DialogResult.Yes:
with Transaction(self.doc, "Set Room Bounding") as tr:
tr.Start()
room_bound.Set(1)
tr.Commit()
return True
return False
return True
except Exception as e:
logger.error(e, exc_info=True)
return False
def create_spaces_by_rooms(self, rooms):
# Initiate the transacton group
with TransactionGroup(self.doc,
"Batch create spaces/Transfer parameters") as tg:
tg.Start()
Room_UniqueIds = [
room.UniqueId for room in rooms
if room.Area > 0 and room.Location != None
]
self.counter += 1
self.ReportProgress.emit(self.counter)
# Define if there're spaces in a model
if self._space_collector.GetElementCount() == 0:
# If there are no spaces
# Create a space
for room in rooms:
if room.Area > 0 and room.UniqueId not in self.New_MEPSpaces:
self.space_creator(room, self.lvls_dict)
self.counter += 1
self.ReportProgress.emit(self.counter)
# If there are spaces in the model
else:
self.space_check(Room_UniqueIds)
# For each room in RVT link rooms take room UniqueId and check if there's space with the same Id among the existing MEP spaces
for room in rooms:
# If there's such space get it
if room.UniqueId in self.Exist_MEPSpaces:
exst_space = self.Exist_MEPSpaces[room.UniqueId]
self.space_updater(room, exst_space)
self.counter += 1
self.ReportProgress.emit(self.counter)
# If there's no such space
else:
# Create a space
if room.Area > 0 and room.UniqueId not in self.New_MEPSpaces:
self.space_creator(room, self.lvls_dict)
self.counter += 1
self.ReportProgress.emit(self.counter)
tg.Assimilate()
def space_creator(self, room, lvls):
'''
Function creates new spaces
room: Revit Room, lvls: level elevations and levels dictionary
'''
try:
# Get the room level
room_lvl = room.Level
# Get a level from the lvls dictionary by room level elevation
lvl = lvls.get(room_lvl.Elevation)
# Create space by coordinates and level taken from room
with Transaction(self.doc, "Batch create spaces") as tr:
tr.Start()
options = tr.GetFailureHandlingOptions()
failureHandler = ErrorSwallower()
options.SetFailuresPreprocessor(failureHandler)
options.SetClearAfterRollback(True)
tr.SetFailureHandlingOptions(options)
room_coords = self.transform.OfPoint(room.Location.Point)
space = self.doc.Create.NewSpace(
lvl, UV(room_coords.X, room_coords.Y))
# Get "REFERENCED_ROOM_UNIQUE_ID" parameter
ref_id_par = space.GetParameters(self._search_id)[0]
# Assign room UniqueID to "REFERENCED_ROOM_UNIQUE_ID" parameter
if ref_id_par:
if ref_id_par.StorageType == StorageType.String:
ref_id_par.Set(room.UniqueId)
self.New_MEPSpaces[
room.UniqueId] = self.New_MEPSpaces.get(
room.UniqueId, space)
self.para_setter(room, space)
else:
ref_id_par.Set(room.Id.IntegerValue)
self.New_MEPSpaces[
room.Id.IntegerValue] = self.New_MEPSpaces.get(
room.Id.IntegerValue, space)
self.para_setter(room, space)
tr.Commit()
except Exception as e:
logger.error(e, exc_info=True)
pass
try:
with Transaction(self.doc, "Set space Id") as tr:
tr.Start()
# Get "ID_revit" parameter of a MEP space
space_id = space.GetParameters("ID_revit")[0]
# Assign space ID to "ID_revit" parameter
if space_id:
space_id.Set(space.Id.IntegerValue)
tr.Commit()
except Exception as e:
logger.error(e, exc_info=True)
pass
def space_updater(self, room, exst_space):
'''
Function updates existing spaces and moves them if necessary
'''
try:
# Extract space coordinates
exst_space_coords = exst_space.Location.Point
# Get room coordinates
room_coords = self.transform.OfPoint(room.Location.Point)
# Compare two sets of coordinates
# If they are almost the same
if exst_space_coords.IsAlmostEqualTo(room_coords):
with Transaction(self.doc, "Update parameters") as tr:
tr.Start()
options = tr.GetFailureHandlingOptions()
failureHandler = ErrorSwallower()
options.SetFailuresPreprocessor(failureHandler)
options.SetClearAfterRollback(True)
tr.SetFailureHandlingOptions(options)
# Transfer room parameters to a corresponding space
self.para_setter(room, exst_space)
tr.Commit()
# Otherwise, move the existing space according to room coordinates
else:
move_vector = room_coords - exst_space_coords
with Transaction(self.doc, "Move spaces") as tr:
tr.Start()
options = tr.GetFailureHandlingOptions()
failureHandler = ErrorSwallower()
options.SetFailuresPreprocessor(failureHandler)
options.SetClearAfterRollback(True)
tr.SetFailureHandlingOptions(options)
exst_space.Location.Move(move_vector)
# Transfer room parameters to a corresponding space
self.para_setter(room, exst_space)
tr.Commit()
except System.MissingMemberException as e:
logger.error(e, exc_info=True)
pass
def space_check(self, Room_UniqueIds):
'''
Function checks for not placed spaces, obsolete spaces and deletes them
'''
# Collect all existing MEP spaces in this document
for space in self._space_collector.ToElements():
# Get "REFERENCED_ROOM_UNIQUE_ID" parameter of each space
id_par_list = space.GetParameters(self._search_id)
ref_id_par_val = id_par_list[0].AsString()
# Check if REFERENCED_ROOM_UNIQUE_ID is in room Room_UniqueIds
# If it's not the case delete the corresponding space
if space.Area == 0 or ref_id_par_val not in Room_UniqueIds:
with Transaction(self.doc, "Delete spaces") as tr:
tr.Start()
try:
self.doc.Delete(space.Id)
except Exception as e:
logger.error(e, exc_info=True)
pass
tr.Commit()
else:
# Otherwise cast it into Existing MEP spaces dictionary
self.Exist_MEPSpaces[
ref_id_par_val] = self.Exist_MEPSpaces.get(
ref_id_par_val, space)
self.counter += 1
self.ReportProgress.emit(self.counter)
def para_setter(self, room, space):
'''
Function transers parameters from the room to newly created spaces
room: Revit Room, space: MEPSpace
'''
# For each parameter in room parameters define if it's shared or builtin parameter
for par in room.Parameters:
par_name = par.Definition.Name
if par.IsShared and par_name in self._excel_parameters:
# If room parameter is shared get space from Spaces dictionary by UniqueId and extract corresponding space parameter from it by room parameter GUID
# Depending on the room parameter storage type set its value to the space parameter
if not par.IsReadOnly:
try:
space_par = space.get_Parameter(par.GUID)
if par.StorageType == StorageType.String and par.HasValue:
space_par.Set(par.AsString())
elif par.StorageType == StorageType.Integer and par.HasValue:
space_par.Set(par.AsInteger())
elif par.StorageType == StorageType.Double and par.HasValue:
space_par.Set(par.AsDouble())
except Exception as e:
logger.error(e, exc_info=True)
pass
self.counter += 1
self.ReportProgress.emit(self.counter)
elif par.Definition.BuiltInParameter != BuiltInParameter.INVALID\
and LabelUtils.GetLabelFor(par.Definition.BuiltInParameter) in self._excel_parameters:
# If room parameter is builtin get space from Spaces dictionary by UniqueId and extract corresponding space parameter from it by builtin parameter
# Depending on the room parameter storage type set its value to the space parameter
if not par.IsReadOnly:
try:
space_par = space.get_Parameter(par.Definition)
if par.StorageType == StorageType.String and par.HasValue:
space_par.Set(par.AsString())
elif par.StorageType == StorageType.Integer and par.HasValue:
space_par.Set(par.AsInteger())
elif par.StorageType == StorageType.Double and par.HasValue:
space_par.Set(par.AsDouble())
except Exception as e:
logger.error(e, exc_info=True)
pass
self.counter += 1
self.ReportProgress.emit(self.counter)
def delete_spaces(self):
'''
Function deletes spaces
'''
self.counter = 0
space_collector = FilteredElementCollector(
self.doc).WhereElementIsNotElementType().OfCategory(
BuiltInCategory.OST_MEPSpaces)
spaces = space_collector.ToElements()
self.startProgress.emit(len(spaces))
with Transaction(self.doc, "Delete spaces") as tr:
tr.Start()
for space in spaces:
try:
self.doc.Delete(space.Id)
self.counter += 1
self.ReportProgress.emit(self.counter)
except Exception as e:
logger.error(e, exc_info=True)
pass
tr.Commit()
self.New_MEPSpaces = {}
self.Exist_MEPSpaces = {}
self.endProgress.emit()
def merge_two_dicts(self, d1, d2):
'''
Merges two dictionaries
Returns a merged dictionary
'''
d_merged = d1.copy()
d_merged.update(d2)
return d_merged
def write_to_excel(self):
"""
Writing parameters to an Excel workbook
"""
self.counter = 0
self.startProgress.emit(self._space_collector.GetElementCount() + \
((self._space_collector.GetElementCount()*len(self._excel_parameters))))
# Obtaining existing spaces
self.__get_exist_spaces()
# Write data to an excel file
self.__write_to_excel(self._excel_parameters)
def __get_exist_spaces(self):
"""
Obtains existing spaces
Fills the Exist_MEPSpaces dictionary: key: reference_room_id, value: MEP space
"""
self.Exist_MEPSpaces = {}
# Collect all existing MEP spaces in this document
for space in self._space_collector:
try:
# Get "REFERENCED_ROOM_UNIQUE_ID" parameter of each space
id_par_list = space.GetParameters(self._search_id)
ref_id_par_val = id_par_list[0].AsString()
# Cast space into Existing MEP spaces dictionary
self.Exist_MEPSpaces[
ref_id_par_val] = self.Exist_MEPSpaces.get(
ref_id_par_val, space)
self.counter += 1
self.ReportProgress.emit(self.counter)
except Exception as e:
logger.error(e, exc_info=True)
pass
def __write_to_excel(self, params_to_write):
"""
Writing parameters to an Excel workbook
(private method)
"""
units = {
UnitType.UT_Length: DisplayUnitType.DUT_METERS,
UnitType.UT_Area: DisplayUnitType.DUT_SQUARE_METERS,
UnitType.UT_Volume: DisplayUnitType.DUT_CUBIC_METERS,
UnitType.UT_Number: DisplayUnitType.DUT_PERCENTAGE,
UnitType.UT_HVAC_Heating_Load: DisplayUnitType.DUT_KILOWATTS,
UnitType.UT_HVAC_Cooling_Load: DisplayUnitType.DUT_KILOWATTS,
UnitType.UT_HVAC_Airflow_Density:
DisplayUnitType.DUT_CUBIC_FEET_PER_MINUTE_SQUARE_FOOT,
UnitType.UT_HVAC_Airflow: DisplayUnitType.DUT_CUBIC_METERS_PER_HOUR
}
columns = list(string.ascii_uppercase) + [
"".join(i) for i in product(string.ascii_uppercase, repeat=2)
]
params = dict(izip(params_to_write, columns))
try:
workBook = self.excel.Workbooks.Open(r'{}'.format(
self._xl_file_path))
workSheet = workBook.Worksheets(1)
except Exception as e:
logger.error(e, exc_info=True)
pass
for par, col in params.items():
workSheet.Cells[1, col] = par
row = 2
MEPSpaces = self.merge_two_dicts(self.New_MEPSpaces,
self.Exist_MEPSpaces)
for space_id, space in MEPSpaces.items():
try:
workSheet.Cells[row, "A"] = space_id
for par in space.Parameters:
par_name = par.Definition.Name
if par_name in params.keys():
if par.StorageType == StorageType.String:
workSheet.Cells[row,
params[par_name]] = par.AsString()
elif par.StorageType == StorageType.Integer:
workSheet.Cells[
row, params[par_name]] = par.AsInteger()
else:
conv_val = UnitUtils.ConvertFromInternalUnits(
par.AsDouble(),
units.get(par.Definition.UnitType,
DisplayUnitType.DUT_GENERAL))
workSheet.Cells[row, params[par_name]] = conv_val
self.counter += 1
self.ReportProgress.emit(self.counter)
row += 1
except Exception as e:
logger.error(e, exc_info=True)
pass
# makes the Excel application visible to the user
self.excel.Visible = True
from Autodesk.Revit.DB import FilteredElementCollector
from Autodesk.Revit.DB import BuiltInCategory, ElementId
from System.Collections.Generic import List
# Required for collection
uidoc = __revit__.ActiveUIDocument
doc = __revit__.ActiveUIDocument.Document
try:
# Try to close PyRevit window
__window__.Close()
except:
pass
collector = FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Doors)
doors = collector.ToElements()
mir_doors = []
for door in doors:
try:
if door.Mirrored:
mir_doors.append(door)
except AttributeError:
pass # foor Symbols that don't have Mirrored attribute.
TaskDialog.Show("Mirrored Doors",
"Mirrored: {} of {} Doors".format(len(mir_doors), len(doors)))
# SELECT MIRRORED DOORS | 2015 + 2016 API
selection = uidoc.Selection
