如何使用Revit API检索墙的原始几何图形？

Question

In a project I need to export a wall 's original geometry to IFC file. The so-called original geometry is the geometry of a wall without being cut by doors or windows hosted on the wall, without connections with roofs, floors, beams, columns, etc. The original geometry I wanted usually should be a shape likes box.

Unfortunately there is no direct Revit API that gives me a wall's original geometry. The element.get_Geometry method return the finally geometry cut by doors, windows and connected floors, roofs, etc.

One possible way to get a wall's original geometry is to rebuild geometry based on the wall's parameters myself, but my lazy method is to let Revit to do the work. My method has five steps as following:

Step 1: Start a Revit transaction.

Step 2: Before calling element.get_Geometry, temporarily delete the doors and windows hosted in the wall, as well as the roofs and floors connected with the wall, from the Revit document.

Step 3: Call document.Regenerate method to updates the elements in the document. Of course the wall's geometry should also be updated.

Step 4: Call element.get_Geometry to get original geometry that I wanted.

Step 5: Rollback the transaction so that the Revit document remains unchanged.

The problem comes out in Step 2. Even if I had delete the doors and windows, there is still openings in the returned geometry.

My question is, how to delete all elements related with a wall?

My Revit version is 2013. The .rvt file I used is rac_basic_sample_project.rvt shipped with Revit. The wall I want export is the wall with id of 117698 or 117654.

My project is based on Revit IFC exporter srouce code.

The following is the code segment I used to get original geometry:

private GeometryElement GetOriginalWallGeometry2(Element element)
{
    Document doc = element.Document;
    GeometryElement geomElem = null;
    //Step 1
    using (Transaction t = new Transaction(doc))
    {
        //Step 2:

        //delete wall joins
        Autodesk.Revit.DB.Wall wall = element as Autodesk.Revit.DB.Wall;

        //assert element is a wall
        //the joined floors or roofs can be deleted as expected.
        if (null != wall)
        {
            while (Autodesk.Revit.DB.WallUtils.IsWallJoinAllowedAtEnd(wall, 0))
            {
                Autodesk.Revit.DB.WallUtils.DisallowWallJoinAtEnd(wall, 0);
            }
            while (Autodesk.Revit.DB.WallUtils.IsWallJoinAllowedAtEnd(wall, 1))
            {
                Autodesk.Revit.DB.WallUtils.DisallowWallJoinAtEnd(wall, 1);
            }
        }

        //The following code of deleting doors doesn't work as expected.
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<Element> elementsList = collector.OfCategory(BuiltInCategory.OST_Doors).ToElements(); //here should be OST_Doors or others?

            foreach (Element elem in elementsList)
            {
                try
                {
                    doc.Delete(elem);
                }
                catch (System.Exception ex)
                {
                }
            }
        }

        //The following code of deleting windows doesn't work as expected.
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<Element> elementsList = collector.OfCategory(BuiltInCategory.OST_Windows).ToElements();//here should be OST_Windows or others?

            foreach (Element elem in elementsList)
            {
                try
                {
                    doc.Delete(elem);
                }
                catch (System.Exception ex)
                {
                }
            }
        }


        //The following code also doesn't work as expected.
        Autodesk.Revit.DB.HostObject hostObj = element as Autodesk.Revit.DB.HostObject;
        if (hostObj != null)
        {
            IList<ElementId> idlist = hostObj.FindInserts(true, true, true, true);
            foreach (ElementId id in idlist)
            {
                try
                {
                    doc.Delete(id);
                }
                catch (System.Exception ex)
                {
                }
            }
        }

        //Floors can be deteled as expected.
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<Element> linkList = collector.OfCategory(BuiltInCategory.OST_Floors).ToElements();

            foreach (Element elelink in linkList)
            {
                try
                {
                    doc.Delete(elelink);
                }
                catch (System.Exception ex)
                {

                }
            }
        }

        //Roofs can be deteled as expected.
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            ICollection<Element> linkList = collector.OfCategory(BuiltInCategory.OST_Roofs).ToElements();

            foreach (Element elelink in linkList)
            {
                try
                {
                    doc.Delete(elelink);
                }
                catch (System.Exception ex)
                {

                }
            }
        }

        //Step 3
        doc.Regenerate();

        //Step 4
        Options options;
        View ownerView = element.Document.GetElement(element.OwnerViewId) as View;
        if (ownerView == null)
        {
            options = GeometryUtil.GetIFCExportGeometryOptions();
        }
        else
        {
            options = new Options();
            options.View = ownerView;
        }
        geomElem = element.get_Geometry(options);

        //Step 5
        FailureHandlingOptions failureOptions = t.GetFailureHandlingOptions();
        failureOptions.SetClearAfterRollback(true);
        failureOptions.SetDelayedMiniWarnings(true);
        t.SetFailureHandlingOptions(failureOptions);
        try
        {
            t.RollBack();
        }
        catch (System.Exception ex)
        {
        }
    }

    return geomElem;
}

Answer 1

I use the following method to retrieve elements of a particular category.

    /// <summary>
    /// Get all elements of the specified type that fall into the specified category
    /// <para>The specified type must derive from Element, or you can use Element but you get everything :)</para>
    /// </summary>
    /// <typeparam name="T">The type of element to get</typeparam>
    /// <param name="builtInCategory">The BuiltinCategory to discriminate the element set</param>
    /// <returns>The collection of elements that match the type and specified categry</returns>
    public IEnumerable<T> GetElements<T>(BuiltInCategory builtInCategory) where T : Element
    {
        FilteredElementCollector collector = new FilteredElementCollector(Document);
        // Seems you must be a subclass of element to use the OfClass method
        if (typeof(T) != typeof(Element))
            collector.OfClass(typeof(T));
        collector.OfCategory(builtInCategory);
        return collector.Cast<T>();
    }

If you are trying to get doors and windows then it would be used as such

var doors = GetElements<FamilyInstance>(BuiltInCategory.OST_DOORS);
var windows = GetElements<FamilyInstance>(BuiltInCategory.OST_WINDOWS);

That presumes that the openings you are looking for are doors or windows.

If you are looking for void extrusions, etc, within the wall or other types of openings then you will need to be more specific in your question.

As a more complex version of the function shown above I use the following method when I wish to also apply a filter against the elements being retrieved.

        /// <summary>
    /// Get the collection of elements of the specified type that are within the provided category that also pass the filter.
    /// <para>The specified type must derive from Element, or you can use Element but you get everything :)</para>
    /// </summary>
    /// <typeparam name="T">The type of element to get</typeparam>
    /// <param name="builtInCategory">The BuiltinCategory to discriminate the element set</param>
    /// <param name="filter">The filter to check the element against</param>
    /// <returns>The collection of elements of the specified type and specified category that pass the filter</returns>
    public IEnumerable<T> GetElements<T>(BuiltInCategory builtInCategory, ElementFilter filter) where T : Element
    {
        FilteredElementCollector collector = new FilteredElementCollector(Document);
        // Seems you must be a subclass of element to use the OfClass method
        if (typeof(T) != typeof(Element))
            collector.OfClass(typeof(T));
        collector.OfCategory(builtInCategory);
        collector.WherePasses(filter);
        return collector.Cast<T>();
    }

The advantage of using the method approach defined above is that it will isolate your code from Revit API changes in the future rather than using the same code blocks repeatedly throughout your code base.

Answer 2

If you want to retrieve Windows, Doors and any other opening on the wall, this is the right code:

var ids = (yourCurrentWallElement as Wall).FindInserts(true, true, true, true);
foreach (ElementId id in ids)
{
    var el = doc.GetElement(id);

    Debug.WriteLine(" Id: " + el.Id);
    Debug.WriteLine(" Type: " + el.GetType().Name);
    Debug.WriteLine(" Category: " + el.Category.Name);
    Debug.WriteLine(" Type: " + el.GetType().Name);

    if (el is FamilyInstance)
    {
        var fi = el as FamilyInstance;
        if (fi != null)
            Debug.WriteLine(" Symbol Name: " + fi.Symbol.Name);
    }
}

More info on the FindInserts -> http://revitapisearch.com/html/58990230-38cb-3af7-fd25-96ed3215a43d.htm

Other example -> http://spiderinnet.typepad.com/blog/2012/04/get-wall-inserts-using-the-revit-wallfindinserts-net-api.html