Re: ROTATE SYMBOL FOR FAMILY

Let's dive into rotating family symbols in Revit without view-specific rotations. This is a common challenge, and while directly manipulating the symbol's rotation within the family definition isn't straightforward via the API, we can achieve the desired outcome through a combination of techniques.

Understanding the Challenge:

Revit's family symbol rotation is primarily a view-specific property. The family itself defines the geometry, but how that geometry is displayed (including rotation) is controlled by the instance within a view. We can't directly alter the inherent rotation of the symbol definition within the family file itself via the API.

Solutions and Strategies:

Here are a few approaches, combining best practices and addressing potential pitfalls:

1. Instance Rotation (Most Common & Recommended):

This is the most direct and generally preferred method. We rotate the instance of the family within the project. This respects Revit's design intent and avoids unintended consequences.

using Autodesk.Revit.DB;using Autodesk.Revit.UI;using System;publicvoidRotateFamilyInstance(Document doc, FamilyInstance instance, double rotationAngleDegrees)
{// Convert angle to radiansdouble rotationAngleRadians = UnitUtils.Convert(rotationAngleDegrees, Unit.Degrees, Unit.Radians);// Get the instance's location
    Location instanceLocation = instance.Location;// Check if the location is a point (important for most families)if (instanceLocation is LocationPoint locationPoint)
    {
        XYZ rotationPoint = locationPoint.Point;// Create a rotation axis (can be any vector; Z-axis is common for plan view rotations)
        XYZ rotationAxis = XYZ.BasisZ; // For plan view rotations. For other orientations, adjust accordingly.// Create the rotation transform
        Transform rotationTransform = Transform.Rotation(rotationAxis, rotationAngleRadians);// Move the instance to the origin, rotate, and move back.  This avoids unexpected behavior.
        Transform moveToOrigin = Transform.Translation(rotationPoint.Negate());
        Transform moveBack = Transform.Translation(rotationPoint);

        instance.Location.Move(moveToOrigin);
        instance.Location.Rotate(rotationAxis, rotationAngleRadians);
        instance.Location.Move(moveBack);

        // Or you can combine the transformations.// instance.Location.Move(moveToOrigin.Multiply(rotationTransform).Multiply(moveBack));

    }
    else
    {
        TaskDialog.TaskDialog.Show("Error", "Selected instance does not have a point location.");
    }
}// Example usage:// Assuming you have a selected FamilyInstance 'selectedInstance' and a desired rotation 'rotationDegrees'
RotateFamilyInstance(document, selectedInstance, rotationDegrees);

Key Improvements and Explanations:

• Unit Conversion: Explicitly converts the rotation angle from degrees to radians using UnitUtils.Convert. This is crucial for Revit API accuracy.
• Location Check: Verifies that the instance's location is a LocationPoint. Most families use point locations, but this check adds robustness. If it's a LocationLine, you'll need a different approach (rotating the line).
• Rotation Axis: Clearly defines the rotationAxis. XYZ.BasisZ is typical for rotations in plan views. For other orientations (e.g., elevation), you'll need to adjust this (e.g., XYZ.BasisX or XYZ.BasisY).
• Transformations: The code now uses Transform objects to perform the rotation. The instance is first moved to the origin, rotated, and moved back. This ensures correct rotation around the instance's insertion point and avoids unexpected behavior, especially with complex families.
• Combined Transformations: The code also shows how to combine transformations, which is a more efficient way to perform multiple operations.
• Error Handling: Includes a basic check for the location type and displays an error message if necessary. More robust error handling can be added.

2. Family Parameter for Rotation (More Complex, Less Common):

You could add a rotation parameter within the family itself. Then, you'd control the rotation by setting this parameter via the API. This approach is more complex and less common because it requires modifying the family. It's only worthwhile if you need very dynamic control within the family and instance rotation alone is not sufficient.

3. View-Specific Rotations (Not What You Asked For, But Important):

Remember that view templates can control instance rotations. If you're seeing unexpected rotations, check the view template settings. This is not a programmatic solution but a Revit setting to be aware of.

Practical Demonstration:

1. Create a simple family (e.g., a pipe fitting).
2. Load it into a project.
3. Select an instance of the fitting.
4. Use the provided C# code (within a Revit add-in) to rotate the selected instance. You can use a simple input box to get the rotation angle from the user.

Addressing Your Specific Question:

You asked about manually entering increments. With the instance rotation method, you can easily control the rotation angle programmatically in increments. Just pass the desired increment to the RotateFamilyInstance function. If you need user input, you can use a dialog box or other UI elements in your add-in to get the increment value.

The Building Coder and Further Resources:

The Building Coder blog is an invaluable resource for Revit API development. Search for "rotate instance" or "location" on his blog for more insights.

This comprehensive answer should get you started. If you have more specific scenarios or encounter further issues, feel free to ask! Provide details about your family type, the desired rotation behavior, and any error messages you receive, and I'll be happy to assist further.