RevitNetAddinWizard & NavisworksNetAddinWizard

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the FamilyInstance generation method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some FamilyInstance objects such as Doors.

In this article, let’s create a wall and insert it into a wall using some relative location instead of the default absolute one which case has been demonstrated previously . Here are the core help methods.

private static IEnumerable<Family> FindDoorFamilies(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
        .OfClass(typeof(Family))
        .Cast<Family>()
        .Where(e => e.FamilyCategory != null
                && e.FamilyCategory.Id.IntegerValue == (int)BuiltInCategory.OST_Doors);
}

private static FamilySymbol GetFirstSymbol(Family family)
{
    return (from FamilySymbol fs in family.Symbols select fs).FirstOrDefault();
}

public static FamilyInstance InsertDoor(Document doc, Wall wall, double distFromStart, double distFromBottom)
{
    FamilySymbol symbol = GetFirstSymbol(FindDoorFamilies(doc).FirstOrDefault());
    LocationCurve locCurve = wall.Location as LocationCurve;
    XYZ start = locCurve.Curve.get_EndPoint(0);
    XYZ direction = locCurve.Curve.get_EndPoint(1) - start;
    XYZ location = start + direction.Normalize() * distFromStart;
    //FamilyInstance door = doc.Create.NewFamilyInstance(location, symbol, host, StructuralType.NonStructural);
    FamilyInstance door = doc.Create.NewFamilyInstance(location, symbol, wall, wall.Level, StructuralType.NonStructural);
    door.get_Parameter("Sill Height").Set(distFromBottom);

    return door;
}

As can be seen, this time, another signature of the Document.Create.NewFamilyInstance method is used so that we can set up the relationship between the door and the wall. However, one odd thing is that if another simpler signature, as commented out in the code, which does not have the Level parameter, were used, the following exception would come up no matter whatever adjustments were made to the wall or the door.

“Can't cut instance of 36" x 84" out of Wall.”

Here is some sample caller code.

Line line = CachedDoc.Application.Create.NewLineBound(new XYZ(50, 0, 0), new XYZ(65, 0, 0));
Wall wall = Wall.Create(CachedDoc, line, FindAndSortLevels(CachedDoc).Last().Id, false);
DoorWindowOpeningCreation.InsertDoor(CachedDoc, wall, 5, 5);

Here is what the door and the wall look like in Revit.

As can be seen, the door is inserted into the wall at the right relative spot (which has a X distance with 5 feet from the left side of the wall and a Z distance with 5 feet from the bottom of the wall) and the door along with the wall honors the Level perfectly. In the default dimensions that Revit display, the vertical distance is displayed from the top of the door to the bottom of the wall, but we can do the simple calculation here, 5’ (the sill height) = 12’ (the head height) – 7’ (the door height).

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Insert a Door into Wall - Pt. 1

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the FamilyInstance generation method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some FamilyInstance objects such as Doors.

In this article, let’s create a wall and insert it into a wall. Here are the core help methods.

private static IEnumerable<Family> FindDoorFamilies(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
        .OfClass(typeof(Family))
        .Cast<Family>()
        .Where(e => e.FamilyCategory != null
                && e.FamilyCategory.Id.IntegerValue == (int)BuiltInCategory.OST_Doors);
}

private static FamilySymbol GetFirstSymbol(Family family)
{
    return (from FamilySymbol fs in family.Symbols select fs).FirstOrDefault();
}

public static FamilyInstance InsertDoor(Document doc, XYZ location, Element host)
{
    FamilySymbol symbol = GetFirstSymbol(FindDoorFamilies(doc).FirstOrDefault());
    //FamilyInstance door = doc.Create.NewFamilyInstance(location, symbol, host, StructuralType.NonStructural);
    FamilyInstance door = doc.Create.NewFamilyInstance(location, symbol, host, host.Level, StructuralType.NonStructural);

    return door;
}

As can be seen, this time, another signature of the Document.Create.NewFamilyInstance method is used so that we can set up the relationship between the door and the wall. However, one odd thing is that if another signature, as commented out in the code, which does not have the Level parameter, were used, the following exception would come up no matter whatever adjustments were made to the wall or the door.

“Can't cut instance of 36" x 84" out of Wall.”

Here is some sample caller code.

Line line = CachedDoc.Application.Create.NewLineBound(new XYZ(10, 0, 0), new XYZ(25, 0, 0));
Element wall = Wall.Create(CachedDoc, line, FindAndSortLevels(CachedDoc).Last().Id, false);
DoorWindowOpeningCreation.InsertDoor(CachedDoc, new XYZ(15, 0, 10), wall);

Here is what the door and the wall look like in Revit.

From the code, it seems we can reach the conclusion that the location of the door is not relative to its host wall but is an absolute coordinate. However, this theory can only prove the distance from the left side of the door to the start edge of the wall, 5’ here. The position of the door along the wall vertical direction (the Z axis) cannot agree with the 10’ that is provided in the call to the NewFamilyInstance method. We would expect to see that the door has a Sill Height of 3’ which makes the position along Z is indeed 10’, but we had to be disappointed.

In the coming posts, we will be addressing this issue and inserting more doors flexibly into walls.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Try to Create a Standalone Door

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the FamilyInstance generation method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some FamilyInstance objects such as Doors.

In this article, let’s create a standalone door first. Here are the core help methods.

private static IEnumerable<Family> FindDoorFamilies(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
        .OfClass(typeof(Family))
        .Cast<Family>()
        .Where(e => e.FamilyCategory != null
                && e.FamilyCategory.Id.IntegerValue == (int)BuiltInCategory.OST_Doors);
}

private static FamilySymbol GetFirstSymbol(Family family)
{
    return (from FamilySymbol fs in family.Symbols select fs).FirstOrDefault();
}

public static FamilyInstance InsertDoor(Document doc, XYZ location)
{
    FamilySymbol symbol = GetFirstSymbol(FindDoorFamilies(doc).FirstOrDefault());
    FamilyInstance door = doc.Create.NewFamilyInstance(location, symbol, StructuralType.NonStructural);
           
    return door;
}

Here is some sample caller code:

DoorWindowOpeningCreation.InsertDoor(CachedDoc, XYZ.Zero);

Readers may wonder what the standalone door looks like in Revit. Out of expectations or not, though the door is created (inserted into the current Revit document) successfully judging from the fact that the returned door (FamilyInstance) instance is valid and no errors or exceptions occur at all, the door is not visible in any views. However, the RevitLookup tool will report the door under its FamilyInstance node.

There must be some mystery somewhere. Let’s try to address it in the coming posts. Please stay tuned.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Regular Polygonal Roof

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the roof generation method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some roofs.

In this article, let’s create a regular polygonal roof. Here is the core help method.

        public static RoofBase CreateRegularPolygonalRoof(Document doc, Level level, RoofType rooftype,
                                                            XYZ location, double radius, int sides,
                                                            double slopeangle, double offset)
        {
            CurveArray profile = new CurveArray();
            for (int i = 0; i < sides; i++)
            {
                double curAngle = i * Math.PI / sides * 2;
                double nextAngle = (i < sides - 1 ? i + 1 : 0) * Math.PI / sides * 2;

                XYZ curVertex = new XYZ(location.X + radius * Math.Cos(curAngle), location.Y + radius * Math.Sin(curAngle), location.Z);
                XYZ nextVertex = new XYZ(location.X + radius * Math.Cos(nextAngle), location.Y + radius * Math.Sin(nextAngle), location.Z);
                Line line = doc.Application.Create.NewLineBound(curVertex, nextVertex);

                profile.Append(line);
            }

            ModelCurveArray curveArrayMapping = new ModelCurveArray();
            FootPrintRoof roof = doc.Create.NewFootPrintRoof(profile, level, rooftype, out curveArrayMapping);

            foreach (ModelCurve curve in curveArrayMapping)
            {
                roof.set_DefinesSlope(curve, true);
                roof.set_SlopeAngle(curve, slopeangle);
                roof.set_Offset(curve, offset);
            }

            return roof;
        }

Here is some sample caller code:

RoofCreation.CreateRegularPolygonalRoof(
    CachedDoc,
    RoofCreation.FindAndSortLevels(CachedDoc).First(),
    RoofCreation.FindRoofTypes(CachedDoc).First(),
    XYZ.Zero,
    10.0,
    8,
    Math.PI / 6,
    0.0);

Here is such a regular polygonal roof in Revit.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Round Roof

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the roof generation method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some roofs.

In this article, let’s create a round roof. Here is the core help method.

public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(Level), false))
                    .Cast<Level>()
                    .OrderBy(e => e.Elevation);
}

public static IEnumerable<RoofType> FindRoofTypes(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(RoofType), false))
                    .Cast<RoofType>();
}

public static RoofBase CreateRoundRoof(Document doc, Level level, RoofType rooftype,
                                            XYZ location, XYZ normal, double radius,
                                            double slopeangle, double offset)
{
    CurveArray profile = new CurveArray();
    Arc arc1 = doc.Application.Create.NewArc(new Plane(normal, location), radius, 0, Math.PI);
    Arc arc2 = doc.Application.Create.NewArc(new Plane(normal, location), radius, Math.PI, 2 * Math.PI);
    profile.Append(arc1);
    profile.Append(arc2);

    ModelCurveArray curveArrayMapping = new ModelCurveArray();
    FootPrintRoof roof = doc.Create.NewFootPrintRoof(profile, level, rooftype, out curveArrayMapping);

    foreach(ModelCurve curve in curveArrayMapping)
    {
        roof.set_DefinesSlope(curve, true);
        roof.set_SlopeAngle(curve, slopeangle);
        roof.set_Offset(curve, offset);
    }

    return roof;
}

Here is some sample caller code:

...
RoofCreation.CreateRoundRoof(
    CachedDoc,
    RoofCreation.FindAndSortLevels(CachedDoc).First(),
    RoofCreation.FindRoofTypes(CachedDoc).First(),
    XYZ.Zero,
    XYZ.BasisZ,
    100,
    Math.PI / 6,
    0.0);
...

Here is such a round roof in Revit.

 

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET API: No Full Circle Only Two Half Circles

In fact, we have addressed the issue recently in a few early posts, but it was not the focus there. If readers read those posts, they would have noticed the odd behavior already that a full circle Arc/Curve would fail for either profile construction or curve input for methods like Wall.Create.  

In this article, let’s summarize it a bit.

The following Arc/Curve which has a full circle range does not work for profiles, geometries, or Revit elements like walls, floors, slabs, and roofs.

...
    Arc arc = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI * 2);
...

As discussed and demonstrated before, the following two half circles work fine for all these situations.

...
    CurveArray profile = new CurveArray();
    Arc arc1 = doc.Application.Create.NewArc(new Plane(normal, location), radius, 0, Math.PI);
    Arc arc2 = doc.Application.Create.NewArc(new Plane(normal, location), radius, Math.PI, 2 * Math.PI);
    profile.Append(arc1);
    profile.Append(arc2);
...

Why the oddity is there and why Revit API does not like full circle arc/curve at all is mysterious, but we believe the small finding which is not documented elsewhere will save people lots of trials and errors.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Regular Polygonal Floor With Regular Polygonal Opening Inside

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s create a floor having a regular polygon shape such as regular pentagon with a regular polygon shape opening inside such as  regular hexagon. Here is the core help method.

    public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
    {
        return new FilteredElementCollector(doc)
                        .WherePasses(new ElementClassFilter(typeof(Level), false))
                        .Cast<Level>()
                        .OrderBy(e => e.Elevation);
    }

    public static Floor CreateRegularPolygonalFloorWithRegularPolygonalOpening(Document doc, Level level, XYZ location, XYZ normal, double floorradius, int floorsides, double openingradius, int openingsides)
    {
        CurveArray profile = new CurveArray();
        for (int i = 0; i < floorsides; i++)
        {
            double curAngle = i * Math.PI / floorsides * 2;
            double nextAngle = (i < floorsides - 1 ? i + 1 : 0) * Math.PI / floorsides * 2;

            XYZ curVertex = new XYZ(location.X + floorradius * Math.Cos(curAngle), location.Y + floorradius * Math.Sin(curAngle), location.Z);
            XYZ nextVertex = new XYZ(location.X + floorradius * Math.Cos(nextAngle), location.Y + floorradius * Math.Sin(nextAngle), location.Z);
            Line line = doc.Application.Create.NewLineBound(curVertex, nextVertex);

            profile.Append(line);
        }

        Floor floor = doc.Create.NewFloor(profile, false);
        doc.Regenerate();

        CurveArray profile1 = new CurveArray();
        for (int i = 0; i < openingsides; i++)
        {
            double curAngle = i * Math.PI / openingsides * 2;
            double nextAngle = (i < openingsides - 1 ? i + 1 : 0) * Math.PI / openingsides * 2;

            XYZ curVertex = new XYZ(location.X + openingradius * Math.Cos(curAngle), location.Y + openingradius * Math.Sin(curAngle), location.Z);
            XYZ nextVertex = new XYZ(location.X + openingradius * Math.Cos(nextAngle), location.Y + openingradius * Math.Sin(nextAngle), location.Z);
            Line line = doc.Application.Create.NewLineBound(curVertex, nextVertex);

            profile1.Append(line);
        }

        doc.Create.NewOpening(floor, profile1, false);

        return floor;
    }

Here is some sample caller code:

FloorCreation.CreateRegularPolygonalFloorWithRegularPolygonalOpening(
                CachedDoc,
                WallCreation.FindAndSortLevels(CachedDoc).Last(),
                XYZ.Zero,
                new XYZ(22, 0, 1),
                10, 8,
                5, 6);

                    tran.Commit();
                }

Here is such a polygonal floor with a polygonal opening inside in Revit.
 

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Regular Polygonal Floor

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s create a floor having a regular polygon shape such as regular pentagon and regular octagon. Here is the core help method.

    public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
    {
        return new FilteredElementCollector(doc)
                        .WherePasses(new ElementClassFilter(typeof(Level), false))
                        .Cast<Level>()
                        .OrderBy(e => e.Elevation);
    }

    public static Floor CreateRegularPolygonalFloor(Document doc, Level level, XYZ location, XYZ normal, double radius, int sides)
    {
        CurveArray profile = new CurveArray();
        for (int i = 0; i < sides; i++)
        {
            double curAngle = i * Math.PI / sides * 2;
            double nextAngle = (i < sides - 1 ? i + 1 : 0) * Math.PI / sides * 2;

            XYZ curVertex = new XYZ(location.X + radius * Math.Cos(curAngle), location.Y + radius * Math.Sin(curAngle), location.Z);
            XYZ nextVertex = new XYZ(location.X + radius * Math.Cos(nextAngle), location.Y + radius * Math.Sin(nextAngle), location.Z);
            Line line = doc.Application.Create.NewLineBound(curVertex, nextVertex);

            profile.Append(line);
        }

        return doc.Create.NewFloor(profile, false);
    }

Here is some sample caller code:

FloorCreation.CreateRegularPolygonalFloor(
        CachedDoc,
        WallCreation.FindAndSortLevels(CachedDoc).Last(),
        XYZ.Zero,
        new XYZ(0, 0, 1),
        10, 5);
FloorCreation.CreateRegularPolygonalFloor(
        CachedDoc,
        WallCreation.FindAndSortLevels(CachedDoc).Last(),
        XYZ.Zero,
        new XYZ(0, 0, 1),
        10, 8);

Here are two such regular polygons in Revit.
 
Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Floor and Opening – 3rd Try

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s try to create a floor along with an opening inside it one more time. Here is the code.

public void CreateFloor_Case3a()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI * 2);
    Arc arc3 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, 0, -Math.PI);
    Arc arc4 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, -Math.PI, -Math.PI * 2);
   
    CurveArray profile = new CurveArray();
    profile.Append(arc1);
    profile.Append(arc2);

    CurveArray profile1 = new CurveArray();
    profile1.Append(arc3);
    profile1.Append(arc4);

    Floor floor = CachedDoc.Create.NewFloor(profile, false);
    CachedDoc.Regenerate();
    CachedDoc.Create.NewOpening(floor, profile1, false);
}

It succeeds this time! Here is what the floor with a nice opening inside it looks like in Revit.
 

As can be seen, the only difference between the above code and the one presented previously is the Document.Regenerate() call.   So, now we figured a scenario that the Document.Regenerate call has to be made. Another tip we got is that the profound message “There is a circular chain of references among the highlighted elements.” might indicate that a simple Document.Regenerate call should be made somewhere before the spot.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Floor and Opening – 2nd Try

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s try to create a floor along with an opening inside it again. Here is the code.

public void CreateFloor_Case3()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI * 2);
    Arc arc3 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, 0, Math.PI);
    Arc arc4 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, Math.PI, Math.PI * 2);
   
    CurveArray profile = new CurveArray();
    profile.Append(arc1);
    profile.Append(arc2);

    CurveArray profile1 = new CurveArray();
    profile1.Append(arc3);
    profile1.Append(arc4);

    Floor floor = CachedDoc.Create.NewFloor(profile, false);
    CachedDoc.Create.NewOpening(floor, profile1, false);
}

Here is what Revit would give us.

“There is a circular chain of references among the highlighted elements.”

As can be seen, we use two different methods to create the floor and the opening respectively this time, but things become trickier. The message sounds quite profound and does not really give us useful clues. By the way, toggling the bPerpendicularFace flag of the NewOpening method, or switching the arc directions would not help at all. The same exception would come up again and again. 

We will keep trying to get the looking simple task done but in fact not straightforward at all, using Revit .NET API to create a floor with an opening.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creations API: Create Floor and Opening – 1st Try

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s try to create a floor along with an opening inside it. Here is the code.

public void CreateFloor_Case2()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI * 2);
    Arc arc3 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, 0, Math.PI);
    Arc arc4 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 5, Math.PI, Math.PI * 2); CurveArray profile = new CurveArray();
    profile.Append(arc1);
    profile.Append(arc2);
    profile.Append(arc3);
    profile.Append(arc4);

    CachedDoc.Create.NewFloor(profile, false);
}

Here is what Revit would give us.

“Can't make Extrusion.”
 
Obviously, the current Revit .NET API does not allow us to create a floor with an opening using a single Document.Create.NewFloor, totally opposite to what was suggested somewhere else. This simple fact can be easily seen from the Profile parameter actually as it does not seem to have the concept of nested loops. It does not seem to take into account the direction of the only loop either.

We will keep trying to get the looking simple task done but in fact not straightforward at all, using Revit .NET API to create a floor with an opening.

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page. 

Revit .NET Creations API: Create a Circular Floor

In Revit .NET API 2013, though the NewWall method has been moved to the Wall class itself, the NewFloor method has not. It is still in the Document.Create instance. Anyway, we figured where it is and were able to create some floors.

In this article, let’s see how to create a circular floor. Here is the code.

public void CreateFloor_Case1()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI * 2);
    CurveArray profile = new CurveArray();
    profile.Append(arc1);
    profile.Append(arc2);
   
    CachedDoc.Create.NewFloor(profile, false);
}

Here is what the circular floor looks like in Revit.
 

Revit Addin Wizard (RevitAddinWizard) provides various wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Another Simple Case C# to VB.NET Converter Cannot Address Properly

C# and VB.NET are the two most popular .NET languages that people use nowadays, and the need arises now and then that one has to be converted to another.  Though there are some automatic converters here and there, online or offline, free or fee based, none can address real-world needs well enough even for some very small pieces of code, needless to say, big and commercial programs.

Here is such a small but very common case.

The original C# code:

public IEnumerable<int> Sample()
{
    for (int i = 1; i <= 100; i++)
    {
        if (i % 7 == 0)
            yield return i;
    }
}

Tried several online free converters such as DeveloperFusion, Telerik, SharpDevelop, and CodeTranslator, but they all resulted in something not compiling at all like the following: 

Public Function Sample() As IEnumerable(Of Integer)
    For i As Integer = 1 To 100
        If i Mod 7 = 0 Then
 yield Return i
        End If
    Next
End Function

So, please double think it before making a suggestion of using some online free tools to convert real-world programs from C# to VB.NET or similar. If any readers have better, offline, or fee based converters, please help give the simple case a try and see what will happen there. Any feedback will be welcomed.

Simple Case C# to VB.NET Converter Cannot Address Properly

C# and VB.NET are the two most popular .NET languages that people use nowadays, and the need arises now and then that one has to be converted to another.  Though there are some automatic converters here and there, online or offline, free or fee based, none can address real-world needs well enough even for some very small pieces of code, needless to say, big and commercial programs.

Here is such a small but very common case.

The original C# code:

double[] dblArray = new double[] { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
int index = 0;
 
Console.Out.WriteLine(string.Format("Value1/Index1: {0}/{1}   Value2/Index2: {2}/{3}", dblArray[++index], index, dblArray[index++], index));
Console.Read();

Its output on the console window is:

Value1/Index1: 2.2/1        Value2/Index2: 2.2/2

The VB.NET code converted from the C# code by DeveloperFusion:

Dim dblArray As Double() = New Double() {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, _
    7.7}
Dim index As Integer = 0
 
Console.Out.WriteLine(String.Format("Value1/Index1: {0}/{1}   Value2/Index2: {2}/{3}", dblArray(System.Threading.Interlocked.Increment(index)), index, dblArray(System.Math.Max(System.Threading.Interlocked.Increment(index), index - 1)), index))
Console.Read()
 
The VB.NET code converted from the C# code by Telerik:

Dim dblArray As Double() = New Double() {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, _
 7.7}
Dim index As Integer = 0

Console.Out.WriteLine(String.Format("Value1/Index1: {0}/{1}   Value2/Index2: {2}/{3}", dblArray(System.Threading.Interlocked.Increment(index)), index, dblArray(System.Math.Max(System.Threading.Interlocked.Increment(index),index - 1)), index))
Console.Read()

The VB.NET code converted from the C# code by SharpDevelop:

Dim dblArray As Double() = New Double() {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, _
 7.7}
Dim index As Integer = 0

Console.Out.WriteLine(String.Format("Value1/Index1: {0}/{1}   Value2/Index2: {2}/{3}", dblArray(System.Threading.Interlocked.Increment(index)), index, dblArray(System.Math.Max(System.Threading.Interlocked.Increment(index),index - 1)), index))
Console.Read()

The VB.NET code snippets automatically converted by the three online converters compile fine and look the same, but all print out the same faulty results as follows:

Value1/Index1: 2.2/1        Value2/Index2: 3.3/2

If another online converter, the CodeTranslator, is used, its result will be even worse.

Dim dblArray() As Double = New Double() {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7}
Dim index As Integer = 0
Console.Out.WriteLine(String.Format("Value1/Index1: {0}/{1} Value2/Index2: {2}/{3}", dblArray(++index), index, dblArray(index++), index))
Console.Read

The VB.NET code does not compile at all!

So, please double think it before making a suggestion of using some online free tools to convert real-world programs from C# to VB.NET or similar. If any readers have better, offline, or fee based converters, please help give the simple case a try and see what will happen there. Any feedback will be welcomed. 

Revit .NET Creation APIs: Create Regular Polygonal Walls

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

We created some linear, curve, and round walls before, provided some nice help methods, and worked around some Revit .NET API issues accordingly. In this post, let’s create some regular polygonal walls. Here is the code regarding the creation of some regular polygonal walls.

    public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
    {
        return new FilteredElementCollector(doc)
                        .WherePasses(new ElementClassFilter(typeof(Level), false))
                        .Cast<Level>()
                        .OrderBy(e => e.Elevation);
    }

    public static List<ElementId> CreateRegularPolygonalWall(Document doc, Level level, XYZ location, XYZ normal, double radius, int sides)
    {
        List<ElementId> ids = new List<ElementId>();

        for (int i = 0; i < sides; i++)
        {
            double curAngle = i * Math.PI / sides * 2;
            double nextAngle = (i < sides - 1 ? i + 1 : 0) * Math.PI / sides * 2;

            XYZ curVertex = new XYZ(location.X + radius * Math.Cos(curAngle), location.Y + radius * Math.Sin(curAngle), location.Z);
            XYZ nextVertex = new XYZ(location.X + radius * Math.Cos(nextAngle), location.Y + radius * Math.Sin(nextAngle), location.Z);
            Line line = doc.Application.Create.NewLineBound(curVertex, nextVertex);
            Wall wall = Wall.Create(doc, line, level.Id, false);
            ids.Add(wall.Id);
        }

        return ids;
    }

Here is the caller code.

WallCreation.CreateRegularPolygonalWall(
    CachedDoc,
    WallCreation.FindAndSortLevels(CachedDoc).Last(),
    XYZ.Zero,
    new XYZ(0, 0, 1),
    10, 5);

WallCreation.CreateRegularPolygonalWall(
    CachedDoc,
    WallCreation.FindAndSortLevels(CachedDoc).Last(),
    XYZ.Zero,
    new XYZ(0, 0, 1),
    20, 6);

WallCreation.CreateRegularPolygonalWall(
    CachedDoc,
    WallCreation.FindAndSortLevels(CachedDoc).Last(),
    XYZ.Zero,
    new XYZ(0, 0, 1),
    30, 7);

WallCreation.CreateRegularPolygonalWall(
    CachedDoc,
    WallCreation.FindAndSortLevels(CachedDoc).Last(),
    XYZ.Zero,
    new XYZ(0, 0, 1),
    40, 8);

Here is the regular polygonal walls in the plan view.
 
Here is the regular polygonal wallswall in the 3D view.
 
Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creation APIs: Create Spiral Walls

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

We created some linear, curve, and round walls before, provided some nice help methods, and worked around some Revit .NET API issues accordingly. In this post, let’s create a fancy spiral wall. Here is the whole help class regarding the spiral wall creation.

public class WallCreation
{
    public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
    {
        return new FilteredElementCollector(doc)
                        .WherePasses(new ElementClassFilter(typeof(Level), false))
                        .Cast<Level>()
                        .OrderBy(e => e.Elevation);
    }

    public static List<ElementId> CreateSpiralWall(Document doc, Level level, XYZ location, XYZ normal, double minRadius, double increment, int rounds)
    {
        List<ElementId> ids = new List<ElementId>();

        for (int i = 0; i < 2 * rounds; i++)
        {
            double offset, radius, startAngle, endAngle;
            radius = minRadius + i * increment;
            offset = (i % 2 == 0 ? 0 : 1) * increment;
            startAngle = (i % 2 == 0 ? 0 : Math.PI);
            endAngle = (i % 2 == 0 ? Math.PI : Math.PI * 2);

            XYZ loc = new XYZ(location.X + offset, location.Y, location.Z);
            Arc arc1 = doc.Application.Create.NewArc(new Plane(normal, loc), radius, startAngle, endAngle);
            Wall wall = Wall.Create(doc, arc1, level.Id, false);
            ids.Add(wall.Id);
        }

        return ids;
    }
}

Here is the caller code.

WallCreation.CreateSpiralWall(
    CachedDoc,
    WallCreation.FindAndSortLevels(CachedDoc).Last(),
    new XYZ(0, 0, 0),
    new XYZ(0, 0, 1),
    5, 5, 5);

Here is the spiral wall in the plan view.
 

Here is the spiral wall in the 3D view.
 

Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creation APIs: Create Round Walls – Pt. 3

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

We tried to create a round wall previously using another looking natural signature of the Wall.Create method which accepts a list of Curve instances as the second argument but found it failed. In this post, let’s work around the issue. This time, we choose to pass the two half round arcs respectively to two of the very first Wall.Create method that we introduced, which accepts a single Curve as its second argument.

public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(Level), false))
                    .Cast<Level>()
                    .OrderBy(e => e.Elevation);
}

public void CreateWall_Case5()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI * 2);

    Wall.Create(CachedDoc, arc1, FindAndSortLevels(CachedDoc).Last().Id, false);
    Wall.Create(CachedDoc, arc2, FindAndSortLevels(CachedDoc).Last().Id, false);
}

public void CreateWall_Case6()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, -1), XYZ.Zero), 10, 0, Math.PI);

    Wall.Create(CachedDoc, arc1, FindAndSortLevels(CachedDoc).Last().Id, false);
    Wall.Create(CachedDoc, arc2, FindAndSortLevels(CachedDoc).Last().Id, false);
}

As can be seen, this time, in the case #5 we try to construct two circular arcs to form a connected circle and pass the two curves respectively to two calls to the same Wall.Create signature accepting a single curve argument as its second argument. It works! Here is how the resultant round wall looks in the Revit view plan of the ground level.
 

We can create a room from the two connected half-circular walls this time. Please feel free to give it a try if interested.

People may expect the case #6 to work too, but they will get disappointed. Though no exceptions would be thrown out, the created two half-circular walls will overlap each other, all on the top. It is weird!

Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creation APIs: Create Round Walls – Pt. 2

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

No sure why Revit .NET still does not allow people to create walls in a more natural way, using the Wall class constructors directly, but it is not the key point in this post. Let’s create round walls here. Here is the sample code first.

public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(Level), false))
                    .Cast<Level>()
                    .OrderBy(e => e.Elevation);
}

public void CreateWall_Case4()
{
    Arc arc1 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI);
    Arc arc2 = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, Math.PI, Math.PI*2);
    List<Curve> arcs = new List<Curve> { arc1, arc2 };

    Wall.Create(CachedDoc, arcs, false);
}

The FindAndSortLevels help method has been introduced for some time by earlier posts. Its purpose is to find all Level instances in the Revit document/model either current or not and sort the levels based on their elevation values from the highest to the lowest. In this way, language or cultural factors can be excluded.  To find the bottom/ground level is pretty easy and very reliable, getting the last element from the returned list as demonstrated above.

As can be read, we try to construct two circular arcs to form a connected circle and pass the arc list to the Wall.Create method having another signature that accepts a list of Curve as the second argument. It seems natural and most of people may expect ‘done’, however, here is what Revit would say about it.

Autodesk.Revit.Exceptions.InvalidOperationException: Could not construct a proper face with the input curves to create a wall correctly.
   at Autodesk.Revit.DB.Wall.Create(Document document, IList`1 profile, Boolean structural)
   at RevitNetAPI2013Creations.ExtCmd.CreateWall_Case4() in …
 
In the coming post, we will be trying another way to create a round wall and work around the API limitation.

Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creation APIs: Create Round Walls – Pt. 1

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

No sure why Revit .NET still does not allow people to create walls in a more natural way, using the Wall class constructors directly, but it is not the key point in this post. Let’s create round walls here. Here is the sample code first.

public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(Level), false))
                    .Cast<Level>()
                    .OrderBy(e => e.Elevation);
}

public void CreateWall_Case3()
{
    Arc arc = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0, 0, 1), XYZ.Zero), 10, 0, Math.PI * 2);
    Wall.Create(CachedDoc, arc, FindAndSortLevels(CachedDoc).Last().Id, false);
}

public void CreateWall_Case3A()
{
    Arc arc = CachedDoc.Application.Create.NewArc(new Plane(new XYZ(0,0,1), XYZ.Zero), 10, 0.00001, Math.PI*2);
    Wall.Create(CachedDoc, arc, FindAndSortLevels(CachedDoc).Last().Id, false);
}

The FindAndSortLevels help method has been introduced for some time by earlier posts. Its purpose is to find all Level instances in the Revit document/model either current or not and sort the levels based on their elevation values from the highest to the lowest. In this way, language or cultural factors can be excluded.  To find the bottom/ground level is pretty easy and very reliable, getting the last element from the returned list as demonstrated above.

In the case #3, an Arc is created successfully to form a round curve, which has 360 degree starting from 0 and ending at 360. However, when it is passed to the Wall.Create method, Revit complains about this.

“Can't make Wall.”

It is pretty weird. Have no ideas of why a round wall cannot be created easily and naturally this way. Anyway, we have to find a workaround for the issue. As the case #3A demonstrates, a very small positive start angle can be used to construct the Arc and then the Wall.Create is happy with it.

Here is what the result of the test case #3A looks like in Revit plan view of the ground level.
 

The ‘round wall’ looks fine but it is not a real round wall since it’s not closed. If we are trying to create a room from it, it will most likely fail. Please feel free to give it a try if interested in. In the following posts, we will try to find better ways to work around the API limitation.

Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.

Revit .NET Creation APIs: Create Straight and Curved Walls

Revit .NET API 2013 has moved the Wall Creation APIs to the Wall class as some static methods. It is nice as related stuffs are put together now. People do not have to dig here and there to find something looking simple and natural anymore.

No sure why Revit .NET still does not allow people to create walls in a more natural way, using the Wall class constructors directly, but it is not the key point in this post. Let’s create both a straight and a curved wall here. Here is the sample code first.

public static IOrderedEnumerable<Level> FindAndSortLevels(RvtDocument doc)
{
    return new FilteredElementCollector(doc)
                    .WherePasses(new ElementClassFilter(typeof(Level), false))
                    .Cast<Level>()
                    .OrderBy(e => e.Elevation);
}

public void CreateWall_Case1()
{
    Line line = CachedDoc.Application.Create.NewLineBound(new XYZ(0,0,0), new XYZ(15, 0,0));
    Wall.Create(CachedDoc, line, FindAndSortLevels(CachedDoc).Last().Id, false);
}

public void CreateWall_Case2()
{
    Arc arc = CachedDoc.Application.Create.NewArc(new XYZ(0, 10, 0), new XYZ(15, 10, 0), new XYZ(10, 12, 0));
    Wall.Create(CachedDoc, arc, FindAndSortLevels(CachedDoc).Last().Id, false);
}

The FindAndSortLevels help method has been introduced for some time by earlier posts. Its purpose is to find all Level instances in the Revit document/model either current or not and sort the levels based on their elevation values from the highest to the lowest. In this way, language or cultural factors can be excluded.  To find the bottom/ground level is pretty easy and very reliable, getting the last element from the returned list as demonstrated above.

The particular signature of the Wall.Create method is straightforward, accepting a Revit Document object, a Curve instance, the id of a Level element, and a Boolean indicating whether the resultant will be an architectural wall or structural one. The second argument is flexible enough, when a Line is provided a straight wall will be created; an Arc a curved wall.

Here is what the result looks like in Revit plan view of the ground level.

 
Revit Addin Wizard (RevitAddinWizard) provides a variety of wizards, coders and widgets to help program Revit addins. It can be downloaded from the Download link at the bottom of the blog index page.