AEC DevBlog

Navisworks API: Resolving Exceptions in LiNwcApiTerminate() When Using NwCreate API

By Naveen Kumar

When working with the Navisworks NwCreate API, you may encounter an exception at LiNwcApiTerminate(). This issue occurs in multiple versions, including NwCreate 2022, 2023, and 2024. This post explains why this happens and how to fix it.

Issue Overview: Following the "Get Started with NwCreate - Part 1" article from the Autodesk Developer Network (ADN) blog, I created a sample project that successfully generates a .nwc file. However, an exception occurs when calling LiNwcApiTerminate(), causing the program to crash.

Cause of the Issue: The main reason for this exception is not properly releasing all handles before calling LiNwcApiTerminate(). If any handles remain open, the API does not shut down cleanly, leading to an error.

Solution: Avoid this issue by ensuring all handles are properly cleaned up. Call LiNwcSceneDestroy(scene); for cleanup

#include <iostream>
#include <tchar.h>
#include "nwcreate/LiNwcAll.h"

// Forward declaration for doExport function
void doExport();

int main()
{
    // Initialise low-level API first.
    LiNwcApiErrorInitialise();
    // Then initialise the rest of the API.
    switch (LiNwcApiInitialise())
    {
    case LI_NWC_API_OK:
        doExport();
        break;
    case LI_NWC_API_NOT_LICENSED:
        printf("Not Licensed\n");
        return 1;
    case LI_NWC_API_INTERNAL_ERROR:
    default:
        printf("Internal Error\n");
        return 1;
    }

    // Terminate API after use
    LiNwcApiTerminate();
    return 0;
}

void doExport()
{
    LtWideString wfilename = L"C:\\test.nwc";
    

    // Create scene and geometry
    LtNwcScene scene = LiNwcSceneCreate();
    LtNwcGeometry geom = LiNwcGeometryCreate();

    if (!scene || !geom)
    {
        printf("Failed to create scene or geometry\n");
        return;
    }

    // Open geometry stream
    LtNwcGeometryStream stream = LiNwcGeometryOpenStream(geom);
    if (!stream)
    {
        printf("Failed to open geometry stream\n");
        LiNwcGeometryDestroy(geom);
        LiNwcSceneDestroy(scene);
        return;
    }

    LiNwcGeometryStreamBegin(stream, 0);
    LiNwcGeometryStreamTriangleVertex(stream, 1, 0, 0);
    LiNwcGeometryStreamTriangleVertex(stream, 2, 0, 10);
    LiNwcGeometryStreamTriangleVertex(stream, 3, 10, 10);
    LiNwcGeometryStreamEnd(stream);
    LiNwcGeometryStreamColor(stream, 0, 1, 0, 1);

    // Close geometry stream
    LiNwcGeometryCloseStream(geom, stream);

    // Add geometry to scene
    LiNwcSceneAddNode(scene, geom);

    // Cleanup geometry
    LiNwcGeometryDestroy(geom);

    // Write NWC file
    if (LiNwcSceneWriteCacheEx(scene, wfilename, wfilename, 0, 0) != LI_NWC_API_OK)
    {
        printf("Failed to write NWC file\n");
    }

    // Destroy scene to free memory
    LiNwcSceneDestroy(scene);
}

Revit API: Handling Conflicts When Two Dynamic Model Updaters Modify the Same Data

By Naveen Kumar

Let's say I have two updaters—one created by the user and the other by the vendor. Both updaters modify the same parameter within an element whenever a change occurs. Since they operate on the same parameter, conflicts may arise due to simultaneous or overlapping modifications, leading to an internal error. The Revit journal logs the issue as follows:

Dynamic Updater with ID xxxxx touched atom ((Element, 147536, -1)) that was previously touched by another updater with ID xxxxx.

If you work with Revit APIs and automation, managing multiple updaters can be a complex and challenging task. So, let's break this down and see what can be done.

What Was Tried (But didn't work)

Several approaches were attempted to fix the issue:

• Changing ChangePriority values – The idea was to set different priority levels so Revit could process one before the other. No luck.

• Using UpdaterRegistry.SetExecutionOrder – This should have controlled the sequence of execution, but the error still happened.

• Using an ExternalEvent – This workaround technically worked, but it’s not ideal. It creates unnecessary or unexpected transactions that the user can undo, potentially leaving the model in an inconsistent state.

Why This Happens?

Revit enforces this restriction to prevent multiple updaters from making conflicting changes to the same data within an element. If both updaters modify the same parameter, there's no way around it—both can't run without interfering with each other.

For developers, this is a nightmare because you don’t want to be in a situation where your updater "stops working" because another vendor’s add-in is overwriting your data. Revit seems to assume that a single vendor should manage all updates to an element to avoid conflicts.

What's The Best Solution?

If you ever run into this situation, here’s what you can do:

• Check if both updaters modify the same parameter. If they do, they are fundamentally incompatible.

• Talk to the third-party vendor. There may be a way to tweak how their updater works so it doesn’t conflict with yours.

• Disable one updater if possible. Depending on the project, you might be able to work around the issue by limiting when one of them runs.

Ultimately, the cleanest solution is to either use a single add-in to modify the specific data or work with the vendor to develop a custom solution that integrates the necessary features of both add-ons without conflicts. Otherwise, expect compatibility issues to keep popping up.

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);
    }
}

Working with Local Coordination Models

By Naveen Kumar

To link a local Coordination Model in Revit, you can use Revit's API to automate the process. The goal is to retrieve all existing Coordination Model instances in your document and check their details to find the one you need. If it isn't already present, you can trigger a command to insert a new local Coordination Model.

First, you access the active document through the `UIDocument` class. Using the `DirectContext3DDocumentUtils.GetDirectContext3DHandleInstances` method, you get all the Coordination Model instances in the document. This method returns a collection of element IDs, which you then loop through to examine each instance.

For each element, you retrieve its type element and check the Path parameter to see if it matches the Coordination Model you're looking for. If the desired model isn't found, you can post a command to open the dialog for inserting a local Coordination Model.

The presented code sample effectively illustrates this procedure. Initially, it retrieves the active document and proceeds to retrieve the instances of Coordination Models. Each instance undergoes thorough examination to identify the Path parameter. In case the desired Coordination Model is not found, users have the option to execute a command that will prompt the insertion of a local Coordination Model. This command can be initiated through either `PostableCommand.CoordinationModelLocal` for Revit versions from 2024 onwards, or `PostableCommand.CoordinationModel` for pre-Revit 2023 versions.

UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Document doc = activeDoc.Document;
ICollection<ElementId> instanceIds = DirectContext3DDocumentUtils.GetDirectContext3DHandleInstances(doc, new ElementId(BuiltInCategory.OST_Coordination_Model));
foreach (var id in instanceIds)
{
    Element elem = doc.GetElement(id);
    if (null != elem)
    {
        Element typeElem = doc.GetElement(elem.GetTypeId());
        if (null != typeElem)
        {
            Parameter param = typeElem.LookupParameter("Path");
            string path = param.AsValueString();
            // Check if this is the CM you're looking for by evaluating 'path'
        }
    }
}

// If the CM is not found, post a command to insert a local CM
RevitCommandId coordinationModeCmdId = RevitCommandId.LookupPostableCommandId(PostableCommand.CoordinationModelLocal);
if (coordinationModeCmdId != null)
{
    commandData.Application.PostCommand(coordinationModeCmdId);
}

Setting multiple PrimitiveTypes for Clash Testing via Navisworks API

By Naveen Kumar

I'd like to delve into a specific aspect of clash testing: setting multiple PrimitiveTypes via Navisworks API. When dealing with clash testing in Navisworks, the ability to specify PrimitiveTypes for clash detection can significantly enhance the accuracy and relevance of clash results. By defining which geometric primitives (such as triangles, lines, or points) should be considered during clash tests, users can tailor the analysis to suit their specific project requirements.

Here's a simple code snippet demonstrating how to set multiple PrimitiveTypes for clash testing using Navisworks API:

Document doc = Autodesk.Navisworks.Api.Application.ActiveDocument;
DocumentClash documentClash = doc.GetClash();
DocumentClashTests oDCT = documentClash.TestsData;
ClashTest t = oDCT.Tests[0] as ClashTest;
ClashTest oCopyt = t.CreateCopy() as ClashTest;
oCopyt.SelectionA.PrimitiveTypes = PrimitiveTypes.Triangles | PrimitiveTypes.Lines;
oCopyt.SelectionB.PrimitiveTypes = PrimitiveTypes.Lines | PrimitiveTypes.Points;
oDCT.TestsEditTestFromCopy(t, oCopyt);

Before running the sample code:




After running the sample code:




If you're new to the Clash Detection API, my colleague Xiaodong has crafted an extensive guide on leveraging its capabilities. These resources offer valuable insights for optimizing clash detection workflows in Autodesk Navisworks.

I encourage you to explore the links provided below.

https://adndevblog.typepad.com/aec/2012/05/navisworks-net-api-2013-new-feature-clash-1.html

https://adndevblog.typepad.com/aec/2012/05/navisworks-net-api-2013-new-feature-clash-2.html

In addition, the Navisworks SDK includes helpful samples specifically focusing on clash detection. To explore these samples, go to 'NET\examples\PlugIns\ClashDetective' in the Navisworks SDK.

 

Navisworks 2024 SDK is posted

By Naveen Kumar

Navisworks 2024 SDK has been posted on ADNOpen: 

https://www.autodesk.com/developer-network/platform-technologies/navisworks

Navisworks 2024 is built against .NET Framework 4.8, which means the application with NET API supports .NET Framework 4.8 and above. The program will need to be compiled by Visual Studio 2022 and .NET Framework 4.8 and above.

In Navisworks 2024 API, We have found an issue of .NET control application.

Issue Description: Autodesk.Navisworks.Api.Controls.ApplicationControl.Initialize() will throw an exception: "External Component has thrown an exception".

Solution: This issue is scheduled to be fixed in future update.

For now, the workaround is to add the installation directory of Navisworks to the path before calling Autodesk.Navisworks.Api.Controls.ApplicationControl.Initialize(); 

(i.e) Environment.SetEnvironmentVariable("PATH",Environment.GetEnvironmentVariable("PATH")+ ";"+nwInstallDir); 

where nwInstallDir has a value corresponding to where NW is installed.

Your sample code will look like this

 static void XMain()
 {
   //Set Environment variable
   string nwInstallDir = @"C:\Program Files\Autodesk\Navisworks Manage 2024";
   Environment.SetEnvironmentVariable("PATH",
                 Environment.GetEnvironmentVariable("PATH")+";"+nwInstallDir);
        
   //Set to single document mode
   Autodesk.Navisworks.Api.Controls.ApplicationControl.ApplicationType=ApplicationType.SingleDocument;

   //Initialise the api
   Autodesk.Navisworks.Api.Controls.ApplicationControl.Initialize();

   Application.EnableVisualStyles();
   Application.SetCompatibleTextRenderingDefault(false);
   Application.Run(new Viewer());

   //Finish use of the API.
   Autodesk.Navisworks.Api.Controls.ApplicationControl.Terminate();
 }

Setting AppearanceAsset properties of newly created Revit Material

By Naveen Kumar

Question: One can change the AppearanceAsset properties of a UI-generated Revit material. However, the AppearanceAssetId value is null if the material is API-generated. The AppearanceAsset properties cannot be set for the material created by the API. Is it possible to modify or set the AppearanceAsset properties of an API-generated Material?

Answer: Since the API-generated material lacks an AppearanceAssetId , it should be set explicitly. In this case, the simplest way to create a new material is to duplicate an existing one and then modify it.

In the code below, red carpet material has been duplicated, and the AppearanceAsset properties of the duplicated material have been modified.

 

public void DuplicateAndModifyMaterial(Material material)
      {
        ElementId appearanceAssetId = material.AppearanceAssetId;
        AppearanceAssetElement assetElem = material.Document
                .GetElement(appearanceAssetId) as AppearanceAssetElement;

        ElementId duplicateAssetElementId = ElementId.InvalidElementId;
        using (Transaction t = new Transaction(material.Document))
         {
            t.Start("Duplicate Red Carpet Material");
           // Duplicate the material
            Material duplicateMaterial = material.Duplicate("Blue Carpet");
           
           // Duplicate the appearance asset and the asset in it
            AppearanceAssetElement duplicateAssetElement = assetElem.Duplicate("Blue Carpet");
           
           // Assign the asset element to the material
            duplicateMaterial.AppearanceAssetId = duplicateAssetElement.Id;
            duplicateAssetElementId = duplicateAssetElement.Id;
            t.Commit();
         }
       // Make changes to the duplicate asset
         using (Transaction t2 = new Transaction(material.Document))
          {
           t2.Start("Change blue carpet material assets");
           using (AppearanceAssetEditScope editScope 
                    = new AppearanceAssetEditScope(assetElem.Document))
            {   
             // returns an editable copy of the appearance asset
              Asset editableAsset = editScope.Start(duplicateAssetElementId);   
                    
             // Description
              AssetPropertyString descriptionProperty =editableAsset
                   .FindByName("description") as AssetPropertyString;
              descriptionProperty.Value = "blue carpet";
                    
             // Diffuse image
              AssetPropertyDoubleArray4d genericDiffuseProperty = editableAsset
                  .FindByName("generic_diffuse") as AssetPropertyDoubleArray4d;
              
              genericDiffuseProperty
                 .SetValueAsColor(new Autodesk.Revit.DB.Color(0x00, 0x00, 0xFF));
              
              Asset connectedAsset = genericDiffuseProperty.GetSingleConnectedAsset();
              AssetPropertyString bitmapProperty = connectedAsset
                   .FindByName("unifiedbitmap_Bitmap") as AssetPropertyString;
                    
             //Appearance tab >>> Generic >>> Image
              bitmapProperty.Value = @"Your image Path here";
              editScope.Commit(true);
            }
           t2.Commit();
          }
      }

Please note: Here in this instance, the "generic_diffuse" property has been accessed. However, not every AppearanceAsset will have the "generic_diffuse" property. So, please use the RevitLookup tool to explore the material element, find the relevant property, and modify it accordingly.

Setting "Units and Transform" values via Navisworks API

By Naveen Kumar

Question: I'm trying to modify the Model Units, Origin, Rotation, and scale values of each appended 3D model. Is it possible to change these values via Navisworks API?

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Answer: Yes, it is possible to change these values using SetModelUnitsAndTransform Method. Please take a look at the below sample code

  
  DocumentModels models = doc.Models;
//Get the required model from DocumentModels
  Model model;

  Transform3D oldTransform3d=model.Transform;
  Transform3DComponents transform3dComponents = oldTransform3d.Factor();

//Get Values
  Vector3D originVector3D = transform3dComponents.Translation;
  Vector3D scaleVector3D = transform3dComponents.Scale;
  Rotation3D rotationVector3D = transform3dComponents.Rotation;

//Set Values
  transform3dComponents.Translation = new Vector3D(origin_X, origin_Y, origin_Z);
  //Eg: new Vector3D(10,10,10);
  
  transform3dComponents.Rotation = new Rotation3D(new UnitVector3D(0, 0, 1), 0.872665);
  //Here 50 degree=0.872665 radian
  
  transform3dComponents.Scale = new Vector3D(scale_X, scale_Y, scale_Z);
  //Eg: new Vector3D(2,2,2);
  
  Transform3D newTransform3D = transform3dComponents.Combine();

//Change model units value
  Units units = Units.Meters;

  models.SetModelUnitsAndTransform(model, units , newTransform3D, true);

Setting Appearance Profiler dat file via Navisworks API

By Naveen Kumar

Description: The Appearance Profiler allows you to set up custom appearance profiles based on sets (search and selection) and property values. You can use them to color-code objects in the model to differentiate system types and visually identify their status. It can be saved as .dat files and shared between other Autodesk Navisworks users.

Autodesk Navisworks 2023 provides a command for appearance profiles. You can use Navisworks automation API and plugin to set appearance profiler to multiple Navisworks files.

Sample Code:

class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            String runtimeName = Resolver.TryBindToRuntime(RuntimeNames.NavisworksManage);
            if (String.IsNullOrEmpty(runtimeName))
            {
                throw new Exception("Failed to bind to Navisworks runtime");
            }
            XMain();
        }

        private static void XMain()
        {
            NavisworksApplication navisApp = new NavisworksApplication();
            navisApp.AppendFile(@"....\InputFile.nwd");
            navisApp.ExecuteAddInPlugin("AutoAppearanceLoader.Navisworks", @"....\AppearanceProfiler.dat");
            navisApp.SaveFile(@"....\OutputFile.nwd");
            navisApp.Dispose();
        }
    }

The command can also work within plugin:

Autodesk.Navisworks.Api.Application.Plugins.ExecuteAddInPlugin("AutoAppearanceLoader.Navisworks", "c:\\temp\\AppearanceProfiler .dat");