Applying Filters

public void IntersectsFilterSample(Document document)
{
        // Use BoundingBoxIntersects filter to find elements with a bounding box that intersects the given Outline in the document.

        // Create a Outline, uses a minimum and maximum XYZ point to initialize the outline. 
        Outline myOutLn = new Outline(new XYZ(0, 0, 0), new XYZ(100, 100, 100));

        // Create a BoundingBoxIntersects filter with this Outline
        BoundingBoxIntersectsFilter filter = new BoundingBoxIntersectsFilter(myOutLn);

        // Apply the filter to the elements in the active document
        // This filter excludes all objects derived from View and objects derived from ElementType
        FilteredElementCollector collector = new FilteredElementCollector(document);
        IList<Element> elements = collector.WherePasses(filter).ToElements();

        // Find all walls which don't intersect with BoundingBox: use an inverted filter to match elements
        // Use shortcut command OfClass() to find walls only
        BoundingBoxIntersectsFilter invertFilter = new BoundingBoxIntersectsFilter(myOutLn, true);
        collector = new FilteredElementCollector(document);
        IList<Element> notIntersectWalls = collector.OfClass(typeof(Wall)).WherePasses(invertFilter).ToElements();
}

public void FindNotSelectedWalls(UIDocument uiDocument)
{
        // Find all walls that are not currently selected, 
        // Get all element ids which are current selected by users, exclude these ids when filtering
        ICollection<ElementId> selectedIds = uiDocument.Selection.GetElementIds();

        // Use the selection to instantiate an exclusion filter
        ExclusionFilter filter = new ExclusionFilter(selectedIds);
        // For the sake of simplicity we do not test here whether the selection is empty or not,
        // but in production code a proper validation would have to be done to avoid an argument
        // exception from the filter's consructor.

        // Apply the filter to the elements in the active document,
        // Use shortcut method OfClass() to find Walls only
        FilteredElementCollector collector = new FilteredElementCollector(uiDocument.Document);
        IList<Element> walls = collector.WherePasses(filter).OfClass(typeof(Wall)).ToElements();
}

public void MakeLoadFilter(Document document)
{
        // Use ElementClassFilter to find all loads in the document
        // Using typeof(LoadBase) will yield all AreaLoad, LineLoad and PointLoad
        ElementClassFilter filter = new ElementClassFilter(typeof(LoadBase));

        // Apply the filter to the elements in the active document
        FilteredElementCollector collector = new FilteredElementCollector(document);
        ICollection<Element> allLoads = collector.WherePasses(filter).ToElements();
}

public void MakeRoomFilter(Document document)
{
        // Use a RoomFilter to find all room elements in the document. It is necessary to use the RoomFilter and not an ElementClassFilter or the shortcut method OfClass() because the Room class is not supported by those methods.
        RoomFilter filter = new RoomFilter();

        // Apply the filter to the elements in the active document
        FilteredElementCollector collector = new FilteredElementCollector(document);
        IList<Element> rooms = collector.WherePasses(filter).ToElements();
}

public void FindRooms(Document document)
{
        // Creates an ElementParameter filter to find rooms whose area is greater than specified value
        // Create filter by provider and evaluator 
        BuiltInParameter areaParam = BuiltInParameter.ROOM_AREA;
        // provider
        ParameterValueProvider pvp = new ParameterValueProvider(new ElementId((long)areaParam));

        // Create an ElementParameter filter to filter rooms whose area is greater than 100 SF
        var ruleGreater100 = new FilterDoubleRule(pvp, new FilterNumericGreater(), 100, 1E-6);
        ElementParameterFilter filterGreater100 = new ElementParameterFilter(ruleGreater100);

        // Apply the filter to the elements in the active document
        IList<Element> roomsGreater100 = new FilteredElementCollector(document)
         .OfCategory(BuiltInCategory.OST_Rooms)
         .WherePasses(filterGreater100).ToElements();

        // Find rooms whose area is less than or equal to 100: 
        // Use inverted filter to match elements
        ElementParameterFilter filterLessthan100 = new ElementParameterFilter(ruleGreater100, true); 
        IList<Element> roomsLessthan100 = new FilteredElementCollector(document)
         .OfCategory(BuiltInCategory.OST_Rooms)
         .WherePasses(filterLessthan100).ToElements();
}

public void FindWoodFamilies(Document document)
{
        // Use FamilyStructuralMaterialType filter to find families whose material type is Wood
        FamilyStructuralMaterialTypeFilter filter = new FamilyStructuralMaterialTypeFilter(StructuralMaterialType.Wood);

        // Apply the filter to the elements in the active document
        FilteredElementCollector collector = new FilteredElementCollector(document);
        ICollection<Element> woodFamiles = collector.WherePasses(filter).ToElements();

        // Find families are not Wood: Use inverted filter to match families
        FamilyStructuralMaterialTypeFilter notWoodFilter = 
                new FamilyStructuralMaterialTypeFilter(StructuralMaterialType.Wood, true);
        collector = new FilteredElementCollector(document);
        ICollection<Element> notWoodFamilies = collector.WherePasses(notWoodFilter).ToElements();
}

IntersectWith() - joins two sets of independent filters

public void FindDoors(Document document)
{
        // Find all door instances in the project by finding all elements that both belong to the door category and are family instances.
ElementClassFilter familyInstanceFilter = new ElementClassFilter(typeof(FamilyInstance));

// Create a category filter for Doors
ElementCategoryFilter doorsCategoryfilter = 
        new ElementCategoryFilter(BuiltInCategory.OST_Doors);

// Create a logic And filter for all Door FamilyInstances
LogicalAndFilter doorInstancesFilter = new LogicalAndFilter(familyInstanceFilter, 
        doorsCategoryfilter);

// Apply the filter to the elements in the active document
FilteredElementCollector collector = new FilteredElementCollector(document);
IList<Element> doors = collector.WherePasses(doorInstancesFilter).ToElements();
}