Traverse all model elements in a project - top-down approach
there is no way to do that directly
using class filter to get all families, and get category via Family.FamilyCategory
using Family.GetFamilySymbolIds() to get all family types,
using FamilyInstanceFilter to get all family instances.
relationship between level and categories is tricky too (but obvious for Revit developers, you should forget all the stuff learned from AutoCAD etc.)
actually, you are saying: get all the categories of the instances on a specific level. i'm afraid you can only use ElementLevelFilter to get all those instances and see what's the categories of those instances.
Dear Chintan,
Thank you for your query.
Aaron is absolutely right.
Basically, the filtered element collector is the one and only channel to retrieve elements from the Revit database.
Before it was 'filtered', it was just an element collector and really slow. Back then, you definitely wanted to retrieve everything of interest in one single call, and then structure it yourself.
Now, you could potantially set up numerous filtered element collectors in loops to achieve the kind of hierarchical query you describe.
You could start like this:
FilteredElementCollector levels
= new FilteredElementCollector( doc )
.OfClass( typeof( Level ) );
foreach( Level level in levels )
{
// Now what?
// We could set up new filtered element
// collectors for each level, but it would
// get complex and we would start repeating
// ourselves...
}
I think it would still be better to get all elements at once, and then sort them into the structure yourself, something like this:
// Get all family instances and use those to
// set up dictionaries for all the required
// mappings in one fell sweep. In the end, we
// will need the following mappings:
// - level to all categories it hosts instances of
// - for each level and category, all families
// - family to its types
// - family type to instances
FilteredElementCollector instances
= new FilteredElementCollector( doc )
.OfClass( typeof( FamilyInstance ) );
// Top level map.
Dictionary<ElementId, // level
List<ElementId>> // categories
mapLevelToCategories = new
Dictionary<ElementId,
List<ElementId>>();
// What we really need is something like this.
// It will probably simplify things to implement
// a custom kind of dictionary for this to add
// new entries very simply.
Dictionary<ElementId, // level
Dictionary<ElementId, // category
Dictionary<ElementId, // family
Dictionary<ElementId, // type
ElementId>>>> // instance
map = new Dictionary<ElementId,
Dictionary<ElementId,
Dictionary<ElementId,
Dictionary<ElementId,
ElementId>>>>();
foreach( FamilyInstance inst in instances )
{
Category cat = inst.Category;
Level lev = doc.GetElement( inst.LevelId ) as Level;
FamilySymbol sym = inst.Symbol;
Family fam = sym.Family;
Debug.Assert( null != cat, "expected valid category" );
Debug.Assert( null != lev, "expected valid level" );
Debug.Assert( null != sym, "expected valid symbol" );
Debug.Assert( null != fam, "expected valid family" );
if( map.ContainsKey( lev.Id ) )
{
mapLevelToCategories[lev.Id].Add( cat.Id );
}
else
{
// First time we encounter this level,
// so start a new level.
List<ElementId> categoriesOnLevel
= new List<ElementId>( 1 );
categoriesOnLevel.Add( cat.Id );
mapLevelToCategories.Add( lev.Id,
categoriesOnLevel );
}
// Sort into families and types pere level and category...
}
I hope this helps.
Best regards,
Jeremy
Dear Chintan,
I am very glad that it helps.
Thank you for your appreciation.
Instances of standard families are represented by FamilyInstance elements.
Instances of system families are represented by native object instances such as Wall, Pipe, Duct, etc.
You will have to enhance and expand the filtered element collector criteria to include the elements you need.
Here is an example to retrieve MEP elements:
http://thebuildingcoder.typepad.com/blog/2010/06/retrieve-mep-elements-and-connectors.html
By the way, I added the filter that I sketched out for you to The Building Coder samples:
#region Traverse all model elements top down Levels > Category > Family > Type > Instance
You might want to share your version of this once you are happy with it and I will put that in instead.
Thank you!
Cheers,
Jeremy
Dear Dale,
Yes, there are simpler approaches, that just require executing a single filtered element collector.
It all depends on what exactly you are after.
Look here for a number of different suggestions and approaches:
http://thebuildingcoder.typepad.com/blog/about-the-author.html#5.9
I hope one of them suits you needs.
How exactly do you define 'model elements'?
Cheers,
Jeremy
Dear Dale,
Does this fit the bill?
IEnumerable<Element> GetAllModelElements(
Document doc )
{
Options opt = new Options();
return new FilteredElementCollector( doc )
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where<Element>( e
=> null != e.Category
&& null != e.get_Geometry( opt ) );
}
I just now added and published this in The Building Coder samples release 2016.0.120.14:
https://github.com/jeremytammik/the_building_coder_samples/releases/tag/2016.0.120.14
Please try it out, and let's ensure that we really get something up and running that suits your needs.
Cheers,
Jeremy
