AEC DevBlog

Revit API: Compact Property Explained

By Naveen Kumar

The Compact File command in Revit plays a crucial role in reducing project file sizes and improving overall efficiency. As projects progress, they often accumulate unused or outdated data, which can lead to larger file sizes and potentially compromise performance.

When you save your Revit file, the Compact File command acts like a purge, systematically removing obsolete data and reorganizing the remaining content. This feature is especially beneficial for older projects that have undergone numerous modifications and have a lengthy saving history, as it can significantly reduce file size by eliminating unnecessary data. Regularly utilizing the Compact File command helps ensure your projects remain efficient, manageable, and run smoothly.

However, it’s important to understand that for new models or files with minimal changes, the Compact File command may have a limited impact. Its true power is revealed in complex, long-term projects that have experienced extensive modifications. In these scenarios, employing the Compact File command can dramatically improve performance and overall manageability.

In the Revit API, the 'Compact' property is available within the SaveOptions and SaveAsOptions classes. When these options are utilized in the Save or SaveAs methods, the Compact File command is executed, providing a seamless way to optimize your project files programmatically.

The SaveAs API and the Compact Property

When using the SaveAs method, the model is always compacted automatically, regardless of whether the 'compact' property is selected. Thus, in this case, the 'compact' property becomes irrelevant, as file compaction occurs by default with every save operation.

This automatic compaction ensures that every time you save a file, outdated elements are removed, and the file remains optimized, contributing to better performance when working with the model.

The Save API and the Compact Property

In the Save API, Revit applies its internal logic to determine whether to trigger the compaction process when the 'compact' property is enabled. However, if the 'compact' property is not selected, Revit bypasses this logic and does not perform any file compaction.

• If the 'compact' property is enabled, Revit assesses the data streams in the file to determine if compaction is necessary. This assessment helps the system decide which outdated elements can be removed.
  
  
• If the 'compact' property is not enabled, the compaction process is skipped, which may result in retaining unnecessary data and potentially larger file sizes as the project continues to evolve.

One suggestion is to use the regenerate all function to update all elements, and then use the "Save" with the "Compact" property to verify if the file size decreases.

 

Navisworks API: Working with Grids And Levels

By Naveen Kumar

In Navisworks, grids and levels are valuable tools for exploring a scene, providing spatial context for your location and the placement of objects within the environment.

You can access grids and levels through the "Grids & Levels" panel in the View tab. Now, let’s utilize the Navisworks API to work with grids and levels.

In this blog post, we will explore the following topics:

• Turns grids on or off
• Customizing grid line colors based on the camera’s position
• Configuring the grid mode
• Setting a specific display level when "Fixed" grid mode is selected

Turns grids on or off

// Access the active document in Navisworks
   Document doc = Autodesk.Navisworks.Api.Application.ActiveDocument;
              
// Retrieve grid options from the Navisworks application
   GridsOptions gridOptions = Autodesk.Navisworks.Api.Application.Options.Grids;
                 
// Enable grid visibility (set to 'false' to hide the grid)
   gridOptions.Enabled = true;

// If X-ray mode is switched off, transparent gridlines hidden by objects will not be displayed.
   gridOptions.XRayMode = true;

Customizing grid line colors based on the camera’s position

// Customize grid line colors based on the camera's position
   gridOptions.AboveColor = new Color(1, 0, 0);  
   gridOptions.BelowColor = new Color(0, 1, 0);  
   gridOptions.OtherColor = new Color(1, 1, 1);      

Configuring the grid mode

// Access the Grids object from the active document
DocumentGrids docGrids = doc.Grids;

// Set the grid render mode to show both above and below grid lines
docGrids.RenderMode = GridsRenderMode.AboveAndBelow; 

Setting a specific display level when "Fixed" grid mode is selected

GridSystem gridSystem = docGrids.ActiveSystem;
// Set the grid render mode to "Fixed" and restrict grid visibility to a specific level 
// e.g., Level 3
// ensuring the grid remains fixed at that level during navigation.             
   GridLevelCollection gridLevelCollection = gridSystem.Levels;
   GridLevel requiredGridLevel = gridLevelCollection.Where(level => level.DisplayName=="Level 3").First();

// Set grid render mode to "Fixed" if Level 3 is found
   if (requiredGridLevel != null)
     { 
       docGrids.RenderMode = GridsRenderMode.Locked;
       docGrids.SetSystemLockedLevel(gridSystem, requiredGridLevel);
     }

Revit API: Retrieving Room Data for Demolished Family Instances

By Naveen Kumar

In Revit projects, it is important to track room data for family instances, especially when they are marked as 'Existing' and later demolished during the 'New Construction' phase.

The Problem: Missing Room Data for Demolished Family Instances

The issue comes from how the Revit API works. The `FamilyInstance.Room` property gives room data based on the final phase of the project. If a family instance has been demolished and no longer exists in the final phase, the API might return incorrect or null values This can be problematic when accurate room data is needed from earlier phases, before the family instance was demolished.

The Solution: Getting Room Data by Phase

To fix this, the Revit API provides a method called `FamilyInstance.get_Room(Phase)`. This allows you to retrieve room information for the specific phase you need, even if the family instance was demolished in a later phase. It ensures you’re getting the right data for each phase, just like in Revit schedules.

Another option is to use `Document.GetRoomAtPoint(XYZ, Phase)`, which retrieves the room based on the family instance’s exact location during a specific phase. This method is useful for more complex cases, ensuring that you get accurate room data regardless of what happens to the family instances in later phases.

// Get the active document and UIDocument from the commandData
Document doc = commandData.Application.ActiveUIDocument.Document;
UIDocument uidoc = commandData.Application.ActiveUIDocument;

// Retrieve all project phases (assuming 3 phases: "Existing", "New Construction", "Final Phase")
FilteredElementCollector phaseCollector = new FilteredElementCollector(doc)
.OfCategory(BuiltInCategory.OST_Phases)
.WhereElementIsNotElementType();

// Find the specific phases by name
Phase existingPhase=phaseCollector.FirstOrDefault(phase=>phase.Name=="Existing") as Phase;
Phase newConstructionPhase=phaseCollector.FirstOrDefault(phase=>phase.Name=="New Construction") as Phase;
Phase finalPhase=phaseCollector.FirstOrDefault(phase=>phase.Name=="Final Phase") as Phase;

// Let the user pick an element (family instance) from the Revit model
Autodesk.Revit.DB.Reference pickedReference = uidoc.Selection.PickObject(ObjectType.Element);
Element pickedElement = doc.GetElement(pickedReference);
FamilyInstance familyInstance = pickedElement as FamilyInstance;

if (familyInstance != null)
{
   // Room in which the family instance is located during the final phase of the project
    Room currentRoom = familyInstance.Room;

   // Access the room the family instance is located in, based on a specific phase
   // Modify this to set the desired phase: existingPhase, newConstructionPhase, or finalPhase
    Phase targetPhase = existingPhase;
    Room roomInSpecificPhase = familyInstance.get_Room(targetPhase);

   // Workaround: Get the family instance's location point 
   //and find the corresponding room in the specified phase.
    LocationPoint familyLocation = familyInstance.Location as LocationPoint;
    if (familyLocation != null)
      {
        XYZ locationPoint = familyLocation.Point;
        Room roomAtPoint = doc.GetRoomAtPoint(locationPoint, targetPhase);
      }
}

Automating Phase-Based View Schedule Creation for Revit Projects

You can also use the Revit API to automate the creation of view schedules for different project phases. Instead of manually creating schedules for each phase, the API can automate this process, linking each schedule to the correct phase and organizing the data properly. This saves time and ensures accuracy across all phases of the project.

// Create a filtered collector to gather all Phase elements in the document
FilteredElementCollector collector = new FilteredElementCollector(doc)
.OfCategory(BuiltInCategory.OST_Phases)
.WhereElementIsNotElementType();
using (Transaction actrans = new Transaction(doc, "Create View Schedules"))
{
  actrans.Start();
  foreach (Element e in collector)
    {
      Phase phase = e as Phase;
      if (phase != null)
        {
          // Create a view schedule for the each phase
           CreateViewSchedule(doc ,phase);
        }
    }
  actrans.Commit();
}

private void CreateViewSchedule(Document doc , Phase phase)
{
  // Create a new view schedule in the document
  //with an InvalidElementId for a multi-category schedule
   ViewSchedule viewSchedule = ViewSchedule.CreateSchedule(doc, ElementId.InvalidElementId);
 
  // Set the name of the schedule
   viewSchedule.Name = "API-" + phase.Name;

  // Set the phase parameter of the view schedule to the required phase
   viewSchedule.get_Parameter(BuiltInParameter.VIEW_PHASE).Set(phase.Id);

   ScheduleDefinition definition = viewSchedule.Definition;

  // Loop through all schedulable fields and add them to the schedule definition
   foreach (SchedulableField sf in definition.GetSchedulableFields())
    {
      ScheduleField field = definition.AddField(sf);
    }
}