def __init__(self, **filters):
"""
Args:
**filters (``keyword args``): Scope and filters
Returns:
Collector (:any:`Collector`): Collector Instance
Scope Options:
* ``view`` `(DB.View)`: View Scope (Optional)
* ``element_ids`` `([ElementId])`: List of Element Ids to limit Collector Scope
* ``elements`` `([Element])`: List of Elements to limit Collector Scope
Warning:
Only one scope filter should be used per query. If more then one is used,
only one will be applied, in this order ``view`` > ``elements`` > ``element_ids``
Filter Options:
* is_type (``bool``): Same as ``WhereElementIsElementType``
* is_not_type (``bool``): Same as ``WhereElementIsNotElementType``
* of_class (``Type``): Same as ``OfClass``. Type can be ``DB.SomeType`` or string: ``DB.Wall`` or ``'Wall'``
* of_category (``BuiltInCategory``): Same as ``OfCategory``. Can be ``DB.BuiltInCategory.OST_Wall`` or ``'Wall'``
* owner_view (``DB.ElementId, View`): ``WhereElementIsViewIndependent(True)``
* is_view_independent (``bool``): ``WhereElementIsViewIndependent(True)``
* family (``DB.ElementId``, ``DB.Element``): Element or ElementId of Family
* symbol (``DB.ElementId``, ``DB.Element``): Element or ElementId of Symbol
* level (``DB.Level``, ``DB.ElementId``, ``Level Name``): Level, ElementId of Level, or Level Name
* not_level (``DB.Level``, ``DB.ElementId``, ``Level Name``): Level, ElementId of Level, or Level Name
* parameter_filter (:any:`ParameterFilter`): Applies ``ElementParameterFilter``
* exclude (`element_references`): Element(s) or ElementId(s) to exlude from result
* and_collector (``collector``): Collector to intersect with. Elements must be present in both
* or_collector (``collector``): Collector to Union with. Elements must be present on of the two.
* where (`function`): function to test your elements against
"""
# Define Filtered Element Collector Scope + Doc
collector_doc = filters.pop('doc') if 'doc' in filters else revit.doc
if 'view' in filters:
view = filters.pop('view')
view_id = view if isinstance(view, DB.ElementId) else view.Id
collector = DB.FilteredElementCollector(collector_doc, view_id)
elif 'elements' in filters:
elements = filters.pop('elements')
element_ids = to_element_ids(elements)
collector = DB.FilteredElementCollector(collector_doc, List[DB.ElementId](element_ids))
elif 'element_ids' in filters:
element_ids = filters.pop('element_ids')
collector = DB.FilteredElementCollector(collector_doc, List[DB.ElementId](element_ids))
else:
collector = DB.FilteredElementCollector(collector_doc)
super(Collector, self).__init__(collector)
for key in filters.keys():
if key not in [f.keyword for f in FilterClasses.get_sorted()]:
raise RpwException('Filter not valid: {}'.format(key))
self._collector = self._collect(collector_doc, collector, filters)
def setUpModule():
logger.title('SETTING UP TESTS...')
logger.title('REVIT {}'.format(version))
collector = DB.FilteredElementCollector(doc)
walls = collector.OfClass(DB.Wall).ToElements()
if walls:
t = DB.Transaction(doc, 'Delete Walls')
t.Start()
for wall in walls:
doc.Delete(wall.Id)
t.Commit()
collector = DB.FilteredElementCollector(doc)
level = collector.OfClass(DB.Level).FirstElement()
pt1 = DB.XYZ(0, 0, 0)
pt2 = DB.XYZ(20, 20, 0)
wall_line = DB.Line.CreateBound(pt1, pt2)
t = DB.Transaction(doc, 'Add Wall')
t.Start()
wall = DB.Wall.Create(doc, wall_line, level.Id, False)
t.Commit()
global wall_int
wall_int = wall.Id.IntegerValue
logger.debug('WALL CREATED.')
collector = DB.FilteredElementCollector(doc)
desk = collector.OfCategory(
DB.BuiltInCategory.OST_Furniture).FirstElement()
if desk:
with rpw.Transaction('Delete Desk'):
f = desk.Family
doc.Delete(f.Id)
##################################################
# Load Fixture Family and Place Instances
##################################################
logger.debug('LOADING SYMBOl')
family_path = os.path.join(test_dir, 'fixtures', 'desk.rfa')
if not os.path.exists(family_path):
raise Exception('Could not find fixture: {}'.format(family_path))
logger.debug('LOADING SYMBOl')
family = clr.Reference[DB.Family]()
with rpw.Transaction('Load Family'):
doc.LoadFamily(family_path, family)
family = family.Value
symbols = []
for family_symbol in family.Symbols:
symbols.append(family_symbol)
with rpw.Transaction('Place Instances'):
level = DB.FilteredElementCollector(doc).OfClass(
DB.Level).WhereElementIsNotElementType().FirstElement()
doc.Create.NewFamilyInstance(DB.XYZ(5, 0, 0), symbols[0], level,
DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(10, 4, 0), symbols[0], level,
DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(15, 8, 0), symbols[1], level,
DB.Structure.StructuralType.NonStructural)
def test_and(self):
col1 = DB.FilteredElementCollector(doc).OfClass(DB.FamilySymbol)
col2 = DB.FilteredElementCollector(doc).OfCategory(
DB.BuiltInCategory.OST_Furniture).IntersectWith(col1)
rv = col2.ToElements()
e = rpw.db.Collector(of_class="FamilySymbol")
rv2 = rpw.db.Collector(of_category='Furniture', and_collector=e)
self.assertEqual(len(rv), len(rv2))
self.assertEqual(rv[0].Id, rv2[0].Id)
self.assertEqual(rv[1].Id, rv2[1].Id)
self.assertEqual(rv[2].Id, rv2[2].Id)
def test_or(self):
col1 = DB.FilteredElementCollector(doc).OfClass(DB.View)
col2 = DB.FilteredElementCollector(doc).OfCategory(
DB.BuiltInCategory.OST_Furniture).UnionWith(col1)
rv = col2.ToElements()
e = rpw.db.Collector(of_class="View")
rv2 = rpw.db.Collector(of_category='Furniture', or_collector=e)
self.assertEqual(len(rv), len(rv2))
self.assertEqual(rv[0].Id, rv2[0].Id)
self.assertEqual(rv[1].Id, rv2[1].Id)
self.assertEqual(rv[2].Id, rv2[2].Id)
def test_match(self):
e1 = DB.FilteredElementCollector(revit.doc).OfClass(
DB.FamilyInstance).WhereElementIsNotElementType().ToElements()[0]
e2 = DB.FilteredElementCollector(revit.doc).OfClass(
DB.FamilyInstance).WhereElementIsNotElementType().ToElements()[1]
o = DB.OverrideGraphicSettings()
o.SetHalftone(True)
o.SetSurfaceTransparency(30)
with rpw.db.Transaction():
self.view_plan.SetElementOverrides(e1.Id, o)
with rpw.db.Transaction():
self.wrapped_view.override.match_element(e2, e1)
rv = self.view_plan.GetElementOverrides(e2.Id)
self.assertTrue(rv.Halftone)
self.assertEqual(rv.Transparency, 30)
def getView3D(doc, viewName):
col = DB.FilteredElementCollector(doc).OfClass(DB.View3D).ToElements()
thumb = None
for View3D in col:
if View3D.Name == viewName:
thumb = View3D
break
return thumb
def _get_elem_by_name_and_cat(name, category):
collector = DB.FilteredElementCollector(doc)
elems = collector.OfCategory(category).WhereElementIsNotElementType()
for elem in elems:
if elem.Name == name:
logger.debug('Elements with name {} was found'.format(name))
return elem
raise ElemNotFound('Not found. Element with name "{}" and category "{}"'.format(name, category))
def delete_all_walls():
collector = DB.FilteredElementCollector(doc)
walls = collector.OfClass(DB.Wall).ToElements()
if walls:
t = DB.Transaction(doc, 'Delete Walls')
t.Start()
for wall in walls:
doc.Delete(wall.Id)
t.Commit()
def setUpClass(cls):
logger.title('TESTING View Classes...')
cls.view = DB.FilteredElementCollector(revit.doc).OfClass(DB.View).FirstElement()
cls.view_plan = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewPlan).FirstElement()
cls.view_sheet = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewSheet).FirstElement()
cls.view_schedule = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewSchedule).FirstElement()
cls.view_section = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewSection).FirstElement()
cls.view_3d = DB.FilteredElementCollector(revit.doc).OfClass(DB.View3D).FirstElement()
cls.view_family_type = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewFamilyType).FirstElement()
def test_excludes(self):
e = DB.FilteredElementCollector(doc).OfClass(DB.View).FirstElement()
e = List[DB.ElementId]([e.Id])
rv = DB.FilteredElementCollector(doc).OfClass(
DB.View).Excluding(e).ToElements()
e = rpw.db.Collector(of_class="View").wrapped_elements[0]
rv2 = rpw.db.Collector(of_class="View", exclude=e)
rv3 = rpw.db.Collector(of_class="View", exclude=[e])
rv4 = rpw.db.Collector(of_class="View", exclude=e.unwrap())
rv5 = rpw.db.Collector(of_class="View", exclude=[e.unwrap()])
rv6 = rpw.db.Collector(of_class="View", exclude=e.Id)
rv7 = rpw.db.Collector(of_class="View", exclude=[e.Id])
self.assertEqual(len(rv), len(rv2))
self.assertEqual(len(rv), len(rv3))
self.assertEqual(len(rv), len(rv4))
self.assertEqual(len(rv), len(rv5))
self.assertEqual(len(rv), len(rv6))
self.assertEqual(len(rv), len(rv7))
def __init__(self, xaml_file_name):
WPFWindow.__init__(self, xaml_file_name)
volume_of_interest = DB.FilteredElementCollector(doc).OfCategory(
DB.BuiltInCategory.OST_VolumeOfInterest)
self.data_grid_content = ObservableCollection[object](
volume_of_interest)
self.datagrid.ItemsSource = self.data_grid_content
self.set_image_source("plus_img", "icons8-plus-32.png")
self.set_image_source("minus_img", "icons8-minus-32.png")
self.set_image_source("import_img", "icons8-import-32.png")
self.set_image_source("ok_img", "icons8-checkmark-32.png")
def get_family_instanse_by_name_and_view_id(name, view_id):
collector = DB.FilteredElementCollector(doc, view_id).OfClass(
DB.FamilyInstance).ToElements()
for elem in collector:
if elem.Symbol.Family.Name == name:
return elem
raise ElemNotFound(
'View #{} do not have family instance named "{}"'.format(
view_id, name))
def make_wall():
collector = DB.FilteredElementCollector(doc)
level = collector.OfClass(DB.Level).FirstElement()
pt1 = DB.XYZ(0, 0, 0)
pt2 = DB.XYZ(20, 20, 0)
wall_line = DB.Line.CreateBound(pt1, pt2)
t = DB.Transaction(doc, 'Add Wall')
t.Start()
wall = DB.Wall.Create(doc, wall_line, level.Id, False)
t.Commit()
return wall
def setUpClass(cls):
logger.title('TESTING View Classes...')
cls.view_plan = revit.active_view.unwrap()
# cls.view_plan = DB.FilteredElementCollector(revit.doc).OfClass(DB.ViewPlan).FirstElement()
cls.wrapped_view = revit.active_view
cls.element = DB.FilteredElementCollector(revit.doc).OfClass(
DB.FamilyInstance).WhereElementIsNotElementType().FirstElement()
linepattern = rpw.db.Collector(of_class='LinePatternElement',
where=lambda x: x.Name == 'Dash').first
cls.line_pattern_id = linepattern.Id
fillpattern = rpw.db.Collector(
of_class='FillPatternElement',
where=lambda x: x.Name == 'Horizontal').first
cls.fillpattern_id = fillpattern.Id
def get_selected_by_cat(categories):
"""
:type categories: list[DB.BuiltInCategory]
:rtype: list[DB.Element]
"""
selections_id = uidoc.Selection.GetElementIds()
if selections_id:
categories_list = List[DB.BuiltInCategory](categories)
filter_cat = DB.ElementMulticategoryFilter(categories_list)
collector = DB.FilteredElementCollector(doc, selections_id).WherePasses(filter_cat).ToElements()
logger.debug('Get selected by category {}'.format(len(collector)))
return collector
def __init__(self, xaml_file_name):
WPFWindow.__init__(self, xaml_file_name)
#
self.data_grid_content = ObservableCollection[PipingSystemType](
DB.FilteredElementCollector(revit.doc).OfClass(PipingSystemType))
self.datagrid.ItemsSource = self.data_grid_content
# Set icons
self.set_image_source("plus_img", "icons8-plus-32.png")
self.set_image_source("minus_img", "icons8-minus-32.png")
self.set_image_source("import_img", "icons8-import-32.png")
self.set_image_source("ok_img", "icons8-checkmark-32.png")
# Set empty external system list source
self.data_grid_imported_content = ObservableCollection[
PipingSystemType]()
self.datagrid_imported.ItemsSource = self.data_grid_imported_content
def setUp(self):
wall = DB.FilteredElementCollector(doc).OfClass(DB.Wall).ToElements()[0]
self.wall = rpw.db.Wall(wall)
with rpw.db.Transaction('Reset Comment') as t:
self.wall.parameters['Comments'] = ''
"""Hides all grid bubbles in the active view."""
from rpw import doc, uidoc, db, DB
from Autodesk.Revit.DB import DatumEnds
grids = DB.FilteredElementCollector(doc)\
.OfCategory(DB.BuiltInCategory.OST_Grids)\
.WhereElementIsNotElementType().ToElements()
with db.Transaction('Hide Grid Bubbles'):
for grid in grids:
grid.HideBubbleInView(DB.DatumEnds.End0, uidoc.ActiveView)
grid.HideBubbleInView(DB.DatumEnds.End1, uidoc.ActiveView)
uidoc.RefreshActiveView()
def createThumbView(doc, viewName):
col = DB.FilteredElementCollector(doc).OfClass(DB.View3D).ToElements()
thumb = DB.View3D.CreateIsometric(doc, col[0].GetTypeId())
thumb.Name = viewName
return thumb
import rpw
from rpw import revit, db, ui, DB, UI
from rpw.ui.forms import *
from System import Array
from System.Runtime.InteropServices import Marshal
import sys
import Autodesk
e_a = str("\xe9")
a_a = str("\xe0")
options = __revit__.Application.Create.NewGeometryOptions()
floor_collector = DB.FilteredElementCollector(revit.doc, revit.doc.ActiveView.Id)\
.OfCategory(DB.BuiltInCategory.OST_Floors)\
.WhereElementIsNotElementType()\
.ToElements()
beam_collector = DB.FilteredElementCollector(revit.doc, revit.doc.ActiveView.Id)\
.OfCategory(DB.BuiltInCategory.OST_StructuralFraming)\
.WhereElementIsNotElementType()\
.ToElements()
level_collector = DB.FilteredElementCollector(revit.doc)\
.OfCategory(DB.BuiltInCategory.OST_Levels)\
.WhereElementIsNotElementType()\
.ToElements()
levels = {}
for level in level_collector:
from airtable import Airtable
from rpw import DB, db, doc
from System.Net import WebClient
__fullframeengine__ = True
# getting default material and assets
provider = DB.ParameterValueProvider(DB.ElementId(DB.BuiltInParameter.MATERIAL_NAME))
rule = DB.FilterStringRule(provider, DB.FilterStringEquals(), "WWI-Generic", False)
base_filter = DB.ElementParameterFilter(rule)
basefabric = (
DB.FilteredElementCollector(doc)
.OfCategory(DB.BuiltInCategory.OST_Materials)
.WherePasses(base_filter)
.ToElements()[0]
)
basefabricA_asset = doc.GetElement(basefabric.AppearanceAssetId)
print("basefabric : " + basefabric.Name + ", asset id : " + basefabricA_asset.Name)
# basefabricR_asset = basefabricA_asset.GetRenderingAsset()
# initiate the Airtable Base - Setting the Airtable base
base_key = "somebasid"
table_name = "Fabrics_List"
api_key = "someapikey"
airtable = Airtable(base_key, table_name, api_key)
fabric_df = airtable.get_all()
folder_path = r"C:\_Local\Bulk_Images"
def setUpClass(cls):
logger.title('TESTING COLLECTOR...')
collector = DB.FilteredElementCollector(doc)
cls.family_loaded = collector.OfCategory(
DB.BuiltInCategory.OST_Furniture).ToElements()
from System.Collections.Generic import List
from rpw import revit, db, ui, DB, UI
# from rpw.ui.forms import *
# from System import Array
# from System.Runtime.InteropServices import Marshal
import sys
import Autodesk
from Autodesk.Revit.DB import *
from Autodesk.Revit.UI import *
clr.AddReference('System.Drawing')
clr.AddReference('System.Windows.Forms')
from System.Drawing import *
from System.Windows.Forms import *
# COLLECT SHEET MAQUETTE
sheet_category = DB.FilteredElementCollector(revit.doc).OfCategory(
BuiltInCategory.OST_Sheets)
sheet_element = sheet_category.WhereElementIsNotElementType()
sheet_name = [sheets.Name for sheets in sheet_element]
sheet_id = [sheets.Id for sheets in sheet_element]
sheet_elementId = [
DB.Document.GetElement(revit.doc, sheets) for sheets in sheet_id
]
# Dictionnary for sheet : keys are names and values are elementId
dico_sheet_nameToElementId = {}
for k in range(len(sheet_name)):
dico_sheet_nameToElementId[str(sheet_name[k])] = sheet_elementId[k]
# COLLECT REVISION MAQUETTE
revisions_category = DB.FilteredElementCollector(revit.doc).OfCategory(
BuiltInCategory.OST_Revisions)
revision_element = revisions_category.WhereElementIsNotElementType()
def setUpClass(cls):
logger.title('TESTING ElementSetTests...')
collector = DB.FilteredElementCollector(doc)
cls.views = collector.OfClass(DB.View).ToElements()
DB.BuiltInCategory.OST_StructuralStiffener,
DB.BuiltInCategory.OST_StructuralTruss,
DB.BuiltInCategory.OST_SwitchSystem,
DB.BuiltInCategory.OST_TelephoneDevices,
DB.BuiltInCategory.OST_Topography,
DB.BuiltInCategory.OST_Walls,
DB.BuiltInCategory.OST_Windows,
DB.BuiltInCategory.OST_Wire,
]
catlist = [ElementId(i) for i in Cat]
typeCatList = List[DB.ElementId](catlist)
# /////////////////////////////////////////////////////////////////////////
# /////////////////////////////////////////////////////////////////////////
# COLLECT LINK INSTANCE
collector_maq = DB.FilteredElementCollector(revit.doc)
linkInstances = collector_maq.OfClass(DB.RevitLinkInstance)
linkDoc = [links.GetLinkDocument() for links in linkInstances]
none_index = [i for i, link in enumerate(linkDoc) if link == None]
linkDoc_name = [link.Name for link in linkInstances]
for index in none_index:
linkDoc_name.pop(index) #remove unload link by finding None in linkDoc
linkDoc_name.insert(0, "Mon document")
#COLLECT WORKSETS IN DOC
collect = DB.FilteredWorksetCollector(revit.doc)
collect_worksets = collect.OfKind(DB.WorksetKind.UserWorkset)
worksets_name_doc = [workset.Name for workset in collect_worksets]
# COLLECT WORKSETS LINKS
collector_maq = DB.FilteredElementCollector(revit.doc)
uidoc = rpw.uidoc
class_dict = {
'family': {
'class': DB.FamilyInstance
},
'system': {
'class': DB.MEPSystem
},
'space': {
'class': DB.SpatialElement
}
}
for k, v in class_dict.items():
element = DB.FilteredElementCollector(doc).OfClass(
class_dict[k]['class']).FirstElement()
class_dict[k]['parameter_name_list'] = sorted(
[parameter.Definition.Name for parameter in element.Parameters])
class_dict[k]['regex'] = re.compile(
r"({})\(([\w\s]+)\)".format(k)) # class_key(parameter_name)
def set_parameter_value(pattern):
with rpw.db.Transaction("Apply pattern to parameters"):
for element in rpw.ui.Selection():
applied_pattern = apply_pattern(element, pattern)
rpw.db.Element(element).parameters['name'].value = applied_pattern
def apply_pattern(element, pattern):
for k, v in class_dict.items():
def test_class(self):
rv = DB.FilteredElementCollector(doc).OfClass(DB.View).ToElements()
rv2 = rpw.db.Collector(of_class="View")
self.assertEqual(len(rv), len(rv2))
def test_category2(self):
rv = DB.FilteredElementCollector(doc).OfCategory(
DB.BuiltInCategory.OST_Levels).WhereElementIsNotElementType(
).ToElements()
rv2 = rpw.db.Collector(of_category="Levels", is_type=False)
self.assertEqual(len(rv), len(rv2))
def setUp(self):
self.wall = DB.FilteredElementCollector(revit.doc).OfClass(
DB.Wall).ToElements()[0]
self.wrapped_wall = rpw.db.Element(self.wall)
#start transaction
with db.Transaction('insert link'):
for path in filepath:
linkpath = DB.ModelPathUtils.ConvertUserVisiblePathToModelPath(
filepath)
linkoptions = DB.RevitLinkOptions(relative=True)
linkloadresult = DB.RevitLinkType.Create(revit.doc, linkpath, linkoptions)
linkinstance = DB.RevitLinkInstance.Create(revit.doc,
linkloadresult.ElementId)
# # Insert from Base Point to Base Point
# DB.RevitLinkInstance.MoveBasePointToHostBasePoint(linkinstance, resetToOriginalRotation = True)
# # Insert from Origin To Origin
# DB.RevitLinkInstance.MoveOriginToHostOrigin(linkinstance, resetToOriginalRotation = True)
# ACQUIRE COORDINATES FROM REVIT LINK
collector_maq = DB.FilteredElementCollector(revit.doc)
linkInstances = collector_maq.OfClass(DB.RevitLinkInstance)
linkDoc = [links.GetLinkDocument() for links in linkInstances]
collector_link = DB.FilteredElementCollector(linkDoc[0])
linkInstancesId = linkInstances.ToElementIds()
# SET COORDINATE TO MAQUETTE
with db.Transaction('set acquire coordinates'):
DB.Document.AcquireCoordinates(revit.doc, linkInstancesId[0])
# GET SITE LOCATION LINK
collector_maq = DB.FilteredElementCollector(revit.doc)
linkInstances = collector_maq.OfClass(DB.RevitLinkInstance)
linkDoc = [links.GetLinkDocument() for links in linkInstances]
collector_link = DB.FilteredElementCollector(linkDoc[0])
projectloc_elements_link = collector_link.OfClass(