Accessing Views to collect all elements of category

Revit
,
1

Hi

I am trying to create an excel file with a list of all doors and all rooms per sheet. Right now I am stuck with pulling the data from the views.

I have a list of sheets and a list of categories and I want to receive a nested dictionary to further process the data towards the excel file:

grafik
grafik1909×1058 335 KB

The dictionary (even though not sorted) is structured as intended but I am struggling to collect the elements from the views per sheet.

This is the python code that I am working on:

import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *
clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

doc = DocumentManager.Instance.CurrentDBDocument

def tolist(input):
    tolist = input if isinstance(input, list) else [input]
    return tolist

def uwlist(input):
    tolist = input if isinstance(input, list) else [input]
    unwrap = UnwrapElement(tolist)
    return unwrap

def supercollector(sheet,category):
    viewsofsheet = sheet.GetAllViewports()
    elems = []
    for view in viewsofsheet:
        elems.append(FilteredElementCollector(doc,view.Id).WhereElementIsNotElementType().ToElements())
    return elems

sheets = uwlist(IN[0])

categories = tolist(IN[1])

output = 	{sheet.SheetNumber: 
				{cat.Name: supercollector(sheet,cat) 
				for cat in categories} 
			for sheet in sheets}

OUT = output

I tried this but I get the following error:

AttributeError : 'ElementId' object has no attribute 'Id' [ File "<string>, line 46, in <module>\n',' File "<string>, line 47, in <dictcomp>\n',' File "<string>, line 47, in <dictcomp>\n',' File "<string>, line 36, in <supercollector>\n']

Line 36 is my supercollector function

Line 46/47 are the output lines and call of that function

The data structure (as shown above) is as intended but the ElementCollector doesn’t collect. Do I have to unwrap the views on my sheets as well or are they unwrapped as soon as I unwrap the sheets? Or do have to use a different method?

I have not yet implemented the category filter because I thought there is no point as long as I can’t collect any elements at all.

Thank you in advance for any help.

2

Welcome to the forum @Marco_Boehm! Congrats on a quite clean first post!

Before we start, did you write this, or did an AI tool? Asking as the way it’s written has a very distinct ‘ah, AI code’ feel to it, but some users starting out can mimic those patterns as they try to look more sophisticated then need be.

Some initial guidance I give users starting out with writing scripts (what I’d call this Python and most content put directly into python nodes), it’s important to not overcomplicate the structure too early. Doubly so with Dynamo’s Python engines, as the error messages return inconsistent line numbers when building stuff out. It may be a copy/paste error or that you removed extra white space or comments, but I only get 38 lines of script here, so line 48 is right out of bounds already and we have to read over what you’ve done to get the content you need. For now try to steer away from using definitions until you get things working as the error messages will be far more useful. The benefit of the definitions are also not being realized here - you only call it once, and while there could be increased performance on the one call that performance gain isn’t sufficient enough in the vacuum of this script. It’s also pretty easy to convert a line by line script into definition(s) where they could provide such performance gains after the fact. Plus a tool that works faster than if you did it by hand is more valuable than a tool which reads nicely but doesn’t work.

As such I recommend avoiding definitions for a bit or telling your AI tool to 'stop using definitions for single calls.

Now to address the issue…

You’re getting the viewports from the ViewSheet class instance, but that API call returns a list of element IDs not a list of elements. This is often the case with API calls which return a list of objects in the Revit model, and a good thing as element IDs have a known size (they’re all 64bit integers after all), and subsequent filters based on element IDs may be wanted as well, while elements can take a LOT more space in memory for each consecutive filter.

So in the line of your supercollector when you call view.Id try just view and you might get what you’re after.

3

Thank you for the fast answer. I did not use AI but rather tried to keep the look of the dictionary comprehension for the output clean if that makes sense. The functions “tolist” and “uwlist” are copies from a YT Tutorial. I thought they might make sense for the boilerplate template if I have a lot more inputs.

Just using view did not work unfortunately.

If I wanted to do this in a single dictionary comprehension how do I loop through the views per sheet?

# Input Sheets und Umwandlung in Liste falls nur eine View reinkommt
sheets = uwlist(IN[0])

# Liste der Kategorien
categories = tolist(IN[1])

output = {sheet.SheetNumber: {cat.Name:[FilteredElementCollector(doc,view).OfClass(cat).WhereElementIsNotElementType().ToElements() for view in viewsofsheet] for cat in categories} for sheet in sheets}

# Ditt kommt raus
OUT = output

The above code will not work beacause I have no list of views at this point. Where do I squeeze in this line?

viewsofsheet = sheet.GetAllViewports()
4

Looking good overall now.

At the moment you’re calling it viewsofsheet doesn’t yet exist, so you’d need to use sheet.GetAllViewports() where you have that in your current list comprehension.

See if that gets you a good result.

I am not sure if OfClass(cat) will work as you’ve currently built stuff, so you might want to be ready for that to fail next.

Which Revit version are you in?

5

Okay I think I finally understand how to nest this correctly. If I use"view" instead of the collector I get a list of the view IDs in my dictionary. I still struggle with accessing the views to collect elements though.

grafik
grafik880×137 9.36 KB

I suppose the problem is that I call the IDs as you said before and not really the elements.

The Warning starts with:

ArgumentException: ViewId is not a view. [...]

This project is in Revit 2023 yet.

6

My next guess is that the output is a viewport, not the view. Silly nested Revit thing, but one to be aware of.

I don’t think I have a working copy of 2023 in any of my systems anymore (you’re doing production work with a Revit version which is almost a quarter year past it’s end of life so it’s time to upgrade), but I’ll see if I can build something using the oldest version I can find.

7

The below sample Python should help you get over the hump. Similar to definitions, don’t fight getting list comprehension to work until you have to, as it will complicate both troubleshooting (the error is somewhere in that line) and authoring (the line will be immensely long - even line 62 of my code is longer in the tooth then I’d like to see for the initial POC). Remember: readability has value in and of itself, something which tutorials often skip over.

The Python 
########################################
############## Properties ##############
########################################
__author__ = 'Jacob Small'
__version__ = '0.0.1'
__description__ = "Gets all elements of a given category which are visible on a sheet, ignoring schedules."
__RevitBuilds__ = "2024.3"
__DynamoBuilds__ = "2.19"
__ReleaseNotes__ = "POC only - test thuroughly before implementing in production. Produced for Dynamo forum thread https://forum.dynamobim.com/t/accessing-views-to-collect-all-elements-of-category/114822/"
__Dependancies__ = "None"
__Copyright__ = "2026, Autodesk Inc."
__License__ = "Apache 2"



########################################
### Configure the Python environment ###
########################################
### standard imports ###
import sys #add the sys class to the Python environment so we can work with the sys objects
import clr #add the CLR (common language runtime) class to the Python environment so we can work with .net libraries

### Dynamo Revit imports ###
import Revit #import Dynamo's Revit node class
clr.ImportExtensions(Revit.Elements) #add the element conversion methods to the CLR
clr.AddReference("RevitServices") #add the Revit services library to the CLR
import RevitServices #import the Revit services class to the Python environment
from RevitServices.Persistence import DocumentManager #import the document manager class to the Python environment 

### Revit API imports ###
clr.AddReference("RevitAPI") #add the Revit API to the CLR
import Autodesk #add the Autodesk class to the Python environment 
from Autodesk.Revit.DB import * #import every class of the Revit API to the Python environment



#########################################
###### Global variables and inputs ######
#########################################
### documents and standard variables ###
doc = DocumentManager.Instance.CurrentDBDocument #the current Revit document

### imports and unwrapping ###
sheets = UnwrapElement(IN[0]) #import the sheets from IN[0] of the Dynamo environment and convert to native Revit elements
if not sheets.__class__ == list : sheets = [sheets] #ensure that sheets is a list, not an individual object, so that we can always prepare for a loop
categories = UnwrapElement(IN[1]) #import the categories from IN[0] of the Dynamo environment and convert to native Revit elements
if not categories.__class__ == list : categories = [categories] #ensure that categories is a list, not an individual object, so that we can always prepare for a loop


#########################################
############ Code goes here #############
#########################################
OUT = {} #define an empty dictionary
for sheet in sheets: #start to loop over the sheets
    sheetName = sheet.Name #get the sheet name
    catLists = {cat.Name:[] for cat in categories} #build a dictionary for the sheet
    for viewport in sheet.GetAllViewports(): #start to loop over the viewports 
        viewId = doc.GetElement(viewport).ViewId #get the assocaited view from the viewpoert
        fec = FilteredElementCollector(doc,viewId).ToElements() #start a filtered element collector (note you can't see an element type in a view so that can likely be skipped)
        for cat in categories: #for each category
            catName = cat.Name #get the category name
            catLists[catName].append([i for i in fec if i.Category and i.Category.Name == catName]) #append the elements in the fec to the key for the category name in the catlists, but only if the element has a category and the category is the one currently being looped over
    OUT[sheetName] = catLists #add a key to the OUT dictionary for the sheet name, with the catLists dictionary as the value
8

Thank you! That works beautifully. I have two questions though:

  1. What do you mean in the comment concerning the fec which could be skipped? Do you mean the ToElements() method?

  2. When adding the items from the fec to the values why do check if the item has a category at all? Shouldn’t checking if the category equals the one of the current loop suffice?

And a tiny structural question: Is there an easy way of flattening the values under the category keys? As of now the values are several lists, one for eacht view of the sheet which does make sense. This is not really a problem though.

I have learned a lot today. Thank you again!

9

You used the WhereElementIsNotElementType() in your original code, which isn’t needed generally when using a view as an input, as you cannot see a type in a view.

If this was C#, or we were hard coding the categories instead of providing them an inputs, yes - including the class in the FEC would be better as those are all ‘quick filters’. But as you’re using Dynamo and Python the are a multitude of ‘converters’ which fail that experience has told me you’re better off avoiding. Categories don’t unwrap to the ‘built in category’ enumerator has like three ‘here is the work around’ that you have to map to your Revit version and no one has time for that mess, especially when you can manage it with a list comprehension on a subsequent line - in this case we only add the elements to the dictionary when the name of the element’s class matches the name of the class we are iterating over.

Right now (in my tests anyway), I have a dictionary for each sheet, and each dictionary contains a key for each class. You can modify the structure if desired by modifying the loop structure. I am not entirely sure what structure you want though. At the moment it’s worth noting that if a door was visible in six views on the sheet you’ll have it listed six times; maybe that’s good, maybe not, but you’ll have to take subsequent actions if so. List.UniqueItems could help there after you pull it from the dictionary.

10

There are some optimisations available in the API

You could use ViewSheet.GetAllPlacedViews() to get a list of view ids

Create a LogicalOrFilter and use the WherePasses() method to grab the desired categories
Indicative code

bic_doors = BuiltInCategory.OST_Doors
bic_rooms = BuiltInCategory.OST_Rooms

ecf_doors = ElementCategoryFilter(bic_doors)
ecf_rooms = ElementCategoryFilter(bic_rooms)

lof = LogicalOrFilter(ecf_doors, ecf_rooms)

elems = FilteredElementCollector(doc, view).WherePasses(lof).ToElements()
11

The logical or filter you’re using is the hard coding of the categories instead of passing them from the Dynamo environment. If hard coding the categories is an option I would recommend using .OfCategory(cat) on the fec, and moving that into the categories loop. However I figured the flexibility of specifying the categories in the graph would be better.

Good catch on the GetAllPlacedViews method. Totally forgot about that one.

12

This is the final structure of the dictionary. But I guess since I will iterate through there again later anyway I don’t need to flatten it at this point.

grafik
grafik847×1203 78.7 KB

Concerning the GetAllPlacedViews(): Wouldn’t that get me IDs only again instead of elements? At least that is what I understand from reading the apidocs.

13

GetElement Method (ElementId) one step away.

14

I don’t know your ultimate goal, but starting with Revit 2023, it is possible to use the “Filter by Sheet” function for schedules placed on sheets; this could greatly simplify your process.

Furthermore, if your view is defined by a scope box, or a custom crop region, FilteredElementCollector(doc, view) could return bad results.

15

Do you have an example of this? I haven’t seen a reproducible case thereof that didn’t involve ‘spillover’ geometry (i.e. points defining a spline in the element’s geometry and the element’s origin cross into or over the extents of the view), which technically is ‘in the view’ even though none of it’s shape is seen. Such shapes would be incredibly rare in the case of both doors and rooms.

16

sure, here is a particular example that should return 6 instances instead of 8

image
image1919×1034 169 KB

Projet_FilteredElementCollector.rvt (7.8 MB)

import clr
import sys
import System

#import Revit API
clr.AddReference('RevitAPI')
import Autodesk
from Autodesk.Revit.DB import \*
import Autodesk.Revit.DB **as** DB

clr.AddReference("System.Core")
clr.ImportExtensions(System.Linq)

clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

doc : DB.Document = DocumentManager.Instance.CurrentDBDocument

active_view = doc.ActiveView

count_inview = FilteredElementCollector(doc, active_view.Id)\\
        .OfCategory(BuiltInCategory.OST_ElectricalFixtures)\\
        .WhereElementIsNotElementType()\\
        .Count()
        

OUT = active_view, f"{count_inview=}"