Program.cs

// MIT License 
// Copyright the Difference Engine Team AECTech 20222 Hackathon
//
// This program uses the VIM SDK (visit https://vimaec.com) to compute 
// delta from a list of VIM files in a folder.
// The folder is passed as a command line arguments
// For every two files compared a JSON file is created containing the list of deltas
// And a geometry file is output in OBJ form for each type of change.

using System.Diagnostics;
using Vim;
using Vim.DotNetUtilities;
using Vim.DotNetUtilities.JsonSerializer;
using Vim.G3d;
using Vim.Geometry;
using Vim.Math3d;

// The different types of changes computed
public enum ChangeType
{
    Unchanged,  // No detected change 
    Addition,   // Addition of a new element ID
    Deletion,   // Removal of an element (looking at element ID)
    Resized,    // Change in volumen of the bounding box 
    Moved,      // Movement of the center of the bounding box in world space
    Changed,    // A change to one of the parameters
};

// Expresses the difference between a node and the previous node. 
record ChangeRecord(
    string ChangeType,
    string Category,
    string FamilyName,
    string FamilyType,
    string PreviousFamilyType,
    int ElementId,
    float Volume,
    float VolumeChange,
    Vector3 Center,
    float DistanceMoved,
    int NodeIndex
);

public static class Program
{
    // The different change types represented as strings 
    public static readonly IReadOnlyList<string> ChangeTypes
        = Enum.GetNames(typeof(ChangeType));

    // The amount of volume change required to consider an object resized (calculated from bounding box)
    public const float VolumeTolerance = 1.0f / 12;

    // The distance required to be moved (calculated from bounding box centers) before an object is considered moved
    public const float PositionTolerance = 1.0f / 12;

    // Creates a change record for a node in the VIM file compared to the previous VIM file
    static ChangeRecord CreateChangeRecord(ChangeType changeType, VimSceneNode node, VimSceneNode? prevNode)
    {
        var box = node.TransformedBoundingBox();
        if (prevNode == null)
        {
            return new(changeType.ToString(), node.CategoryName, node.FamilyName, node.FamilyTypeName, "", node.ElementId,
                box.Volume, 0, box.Center, 0, node.Id);
        }

        var prevBox = prevNode.TransformedBoundingBox();
        return new(changeType.ToString(), node.CategoryName, node.FamilyName, node.FamilyTypeName, prevNode.FamilyTypeName,
            node.ElementId, box.Volume, box.Volume - prevBox.Volume, box.Center, prevBox.Center.Distance(box.Center),
            node.Id);
    }

    // Outputs a single OBJ file containing the geometry of all objects of a specific change Type 
    static void OutputObj(IEnumerable<ChangeRecord> changes, VimScene vim, ChangeType changeType, int prefix,
        string outputFolder)
    {
        var meshes = changes.Where(c => c.ChangeType == changeType.ToString())
            .Select(c => vim.VimNodes[c.NodeIndex].TransformedMesh());
        if (!meshes.Any()) return;
        meshes.Merge().ToG3d().WriteObj(Path.Combine(outputFolder, $"{changeType}_{prefix}.obj"));
    }

    // A simplistic computation to check if the family or family type changed. 
    // A more sophisticated algorithm would create a detailed comparison of parameters and common field values 
    static bool IsChanged(VimSceneNode node1, VimSceneNode node2)
        => node1.FamilyName != node2.FamilyName
           || node1.FamilyTypeName != node2.FamilyTypeName;

    /// Main entry point of the script 
    public static void Main(params string[] args)
    {
        // Start a stopwatch
        var sw = Stopwatch.StartNew();

        // The first parameter on the command line is the input folder 
        var inputFolder = args[0];
        
        // Get all of the VIM files in the input folder ordered by their name
        var vimFilePaths = Directory.GetFiles(inputFolder, "*.vim").OrderBy(f => f).ToList();
        
        // Output folder is created as a sub-folder of the input folder and is named 
        var outputFolder = Path.Combine(inputFolder, "output");
        Util.CreateAndClearDirectory(outputFolder);
        
        // We are going to loop through all VIM files and load them in memory one by one 
        // comparing with the previous one. 
        var prevVim = VimScene.LoadVim(vimFilePaths[0]);
        for (var i = 0; i < vimFilePaths.Count; ++i)
        {
            // When looking at the first file we have to treat it as a special case, so current and previous is the same 
            var currVim = i > 0 ? VimScene.LoadVim(vimFilePaths[i]) : prevVim;

            var prevNodes = prevVim.VimNodesWithGeometry().ToDictionaryIgnoreDuplicates(n => n.ElementId, n => n);
            var currNodes = currVim.VimNodesWithGeometry().ToDictionaryIgnoreDuplicates(n => n.ElementId, n => n);

            var changes = new List<ChangeRecord>();
            foreach (var currNode in currVim.VimNodesWithGeometry())
            {
                // All nodes in the first file are treated as additions 
                // In other files, 
                if (i == 0 || !prevNodes.ContainsKey(currNode.ElementId))
                {
                    changes.Add(CreateChangeRecord(ChangeType.Addition, currNode, null));
                }
                else
                {
                    // Look for the different possible types of change 
                    var prevNode = prevNodes[currNode.ElementId];

                    var prevBox = prevNode.TransformedBoundingBox();
                    var currBox = currNode.TransformedBoundingBox();

                    if (IsChanged(prevNode, currNode))
                    {
                        changes.Add(CreateChangeRecord(ChangeType.Changed, currNode, prevNode));
                    }
                    else if (!prevBox.Volume.AlmostEquals(currBox.Volume, VolumeTolerance))
                    {
                        changes.Add(CreateChangeRecord(ChangeType.Resized, currNode, prevNode));
                    }
                    else if (!prevBox.Center.AlmostEquals(currBox.Center, PositionTolerance))
                    {
                        changes.Add(CreateChangeRecord(ChangeType.Moved, currNode, prevNode));
                    }
                    else
                    {
                        changes.Add(CreateChangeRecord(ChangeType.Unchanged, currNode, prevNode));
                    }
                }
            }

            // To look for deleted nodes we have to loop through the previous nodes
            // We can skip this process if we are in a new node
            if (i != 0)
            {
                foreach (var node1 in prevVim.VimNodesWithGeometry())
                {
                    if (!currNodes.ContainsKey(node1.ElementId))
                    {
                        changes.Add(CreateChangeRecord(ChangeType.Deletion, node1, null));
                    }
                }
            }

            // Output a merged OBJ for each change type 
            OutputObj(changes, currVim, ChangeType.Changed, i, outputFolder);
            OutputObj(changes, currVim, ChangeType.Moved, i, outputFolder);
            OutputObj(changes, currVim, ChangeType.Resized, i, outputFolder);
            OutputObj(changes, currVim, ChangeType.Addition, i, outputFolder);
            OutputObj(changes, currVim, ChangeType.Unchanged, i, outputFolder);

            // Notice that Deletion records required the previous VIM 
            OutputObj(changes, prevVim, ChangeType.Deletion, i, outputFolder);

            // The delta file contains all of the change records 
            var deltaFile = Path.Combine(outputFolder, $"delta_{i}.json");
            changes.ToJsonFile(deltaFile);
            prevVim = currVim;
        }

        Util.OutputTimeElapsed(sw, "Computing all deltas");
    }
}