Autodesk forge Autodesk Forge：模型比较（BIM 360功能）

Bim 360有一个名为“比较版本”的强大工具，可以查看两个Revit模型之间的更改。有关此功能的更多信息，请访问：

---

是否在Autodesk Forge中找到此功能？我还没有找到它，我确实看到forge有一个BIM 360 API，但我没有看到这个功能可用。

没有，至少现在没有。那太好了，不是吗？也许将来

不，至少现在是这样。那太好了，不是吗？也许将来

您可以使用sdk执行此操作

ForgeAuthor是一个基于.NETFramework4.5的.net库，它提供了一种很好的面向对象的方法来操作AudeskForge Svf模型，简单到操作XML或JSON

作者可以读取Autodesk Forge SVF模型，比较差异，并生成差异模型

#region setup materials

                var matUnmodified = new Material
                {
                    Color = Vector3D.FromColor(0xffffff), //Darker: Vector3D.FromColor(0x101010)
                    Transparent = 0.95,
                    Reflectivity = 0
                };

                var matAdd = new Material
                {
                    Color = Vector3D.FromColor(Color.GreenYellow)
                };

                var matDelete = new Material
                {
                    Color = Vector3D.FromColor(Color.Red)
                };

                var matModifiedBefore = new Material
                {
                    Color = Vector3D.FromColor(Color.Orange),
                    Transparent = 0.5
                };

                var matModifiedAfter = new Material
                {
                    Color = Vector3D.FromColor(Color.Aqua),
                };

                #endregion

                var baseModelPath = txtBaseModel.Text;
                var incrModelPath = txtIncrementModel.Text;
                var diffModelPath = txtDiffModel.Text;

                var svfbase = baseModelPath.EndsWith(@"zip")
                    ? SvfDocument.LoadFromZipFile(baseModelPath)
                    : SvfDocument.LoadFromSvfFile(baseModelPath);

                var svfincr = incrModelPath.EndsWith(@"zip")
                    ? SvfDocument.LoadFromZipFile(incrModelPath)
                    : SvfDocument.LoadFromSvfFile(incrModelPath);

                var compareResult = CompareModel(svfbase, svfincr);

                var svfdiff = new SvfDocument();
                svfdiff.Model.Name = @"Diff Model";
                svfdiff.Metadata = svfbase.Metadata;

                var nodeUnmodified = svfdiff.Model.Children.CreateNode();
                nodeUnmodified.Name = @"Unmodified";

                var nodeAdded = svfdiff.Model.Children.CreateNode();
                nodeAdded.Name = @"Added";

                var nodeDeleted = svfdiff.Model.Children.CreateNode();
                nodeDeleted.Name = @"Deleted";

                var nodeModifiedBefore = svfdiff.Model.Children.CreateNode();
                nodeModifiedBefore.Name = @"Modified Before";

                var nodeModifiedAfter = svfdiff.Model.Children.CreateNode();
                nodeModifiedAfter.Name = @"Modified After";

                svfbase.EnumerateNodes(node =>
                {
                    if (node.Children?.Count == 0 &&
                        node.Fragments?.Count > 0 &&
                        string.IsNullOrEmpty(node.ExternalId) == false)
                    {
                        if (compareResult.Unmodified.Remove(node.ExternalId))
                        {
                            ImportNodeWithPath(nodeUnmodified, node, svfbase.Model, matUnmodified);
                        }
                        else if (compareResult.Deleted.Remove(node.ExternalId))
                        {
                            ImportNodeWithPath(nodeDeleted, node, svfbase.Model, matDelete);
                        }
                        else if (compareResult.Modified.Contains(node.ExternalId))
                        {
                            var targetNode =
                                ImportNodeWithPath(nodeModifiedBefore, node, svfbase.Model, matModifiedBefore);
                            targetNode.ExternalId += @"_Before";
                        }
                    }
                }, svfbase.Model);

                svfincr.EnumerateNodes(node =>
                {
                    if (node.Children?.Count == 0 &&
                        node.Fragments?.Count > 0 &&
                        string.IsNullOrEmpty(node.ExternalId) == false)
                    {
                        if (compareResult.Added.Remove(node.ExternalId))
                        {
                            ImportNodeWithPath(nodeAdded, node, svfincr.Model, matAdd);
                        }
                        else if (compareResult.Modified.Remove(node.ExternalId))
                        {
                            ImportNodeWithPath(nodeModifiedAfter, node, svfincr.Model, matModifiedAfter);
                        }
                    }
                }, svfincr.Model);

                svfdiff.SaveToFolder(diffModelPath, true);
                svfdiff.Dispose();

                svfbase.Dispose();
                svfincr.Dispose();



private (HashSet<string> Unmodified, HashSet<string> Added, HashSet<string> Deleted, HashSet<string> Modified)
        CompareModel(SvfDocument svfbase, SvfDocument svfincr)
    {
        var baseNodes = new Dictionary<string, SvfNode>();
        svfbase.EnumerateNodes(node =>
        {
            if (node.Children?.Count == 0
                && node.Fragments?.Count > 0
                && string.IsNullOrEmpty(node.ExternalId) == false)
            {
                baseNodes[node.ExternalId] = node;
            }
        }, svfbase.Model);

        var elementsAdded = new HashSet<string>();
        var elementsUnmodified = new HashSet<string>();
        var elementsModified = new HashSet<string>();
        var elementsDeleted = new HashSet<string>();

        svfincr.EnumerateNodes(node =>
        {
            if (node.Children?.Count == 0
                && node.Fragments?.Count > 0
                && string.IsNullOrEmpty(node.ExternalId) == false)
            {
                if (baseNodes.TryGetValue(node.ExternalId, out SvfNode baseNode))
                {
                    if (baseNode.Fragments.Equals(node.Fragments))
                    {
                        elementsUnmodified.Add(node.ExternalId); //unmdified
                    }
                    else
                    {
                        elementsModified.Add(node.ExternalId); //modified
                    }

                    baseNodes.Remove(node.ExternalId);
                }
                else
                {
                    elementsAdded.Add(node.ExternalId); //added
                }
            }
        }, svfincr.Model);

        foreach (var p in baseNodes.Keys)
        {
            elementsDeleted.Add(p); //deleted
        }
        baseNodes.Clear();

        return (elementsUnmodified, elementsAdded, elementsDeleted, elementsModified);
    }

    private SvfNode ImportNodeWithPath(SvfNode targetNodeRoot, SvfNode sourceNode, SvfNode sourceNodeRoot, Material material)
    {
        var targetNode = sourceNode.Parent == sourceNodeRoot
            ? targetNodeRoot
            : ImportNodeWithPath(targetNodeRoot, sourceNode.Parent, sourceNodeRoot, material);
        var resultNode = targetNode.Children.FirstOrDefault(x => x.Name == sourceNode.Name);
        if (resultNode == null)
        {
            resultNode = targetNode.Children.ImportNode(sourceNode, null, false);
            foreach (var fragment in resultNode.Fragments)
            {
                fragment.Material = material;
            }
        }
        return resultNode;
    }

#区域设置材料
var MATUNMODIFED=新材料
{
Color=Vector3D.FromColor（0xffffff），//更暗：Vector3D.FromColor（0x101010）
透明=0.95，
反射率=0
};
var matAdd=新材料
{
Color=Vector3D.FromColor（Color.GreenYellow）
};
var matDelete=新材料
{
Color=Vector3D.FromColor（Color.Red）
};
var matModifiedBefore=新材料
{
Color=Vector3D.FromColor（Color.Orange），
透明=0.5
};
var matModifiedAfter=新材料
{
Color=Vector3D.FromColor（Color.Aqua），
};
#端区
var baseModelPath=txtBaseModel.Text；
var incrModelPath=txtIncrementModel.Text；
var diffModelPath=txtDiffModel.Text；
var svfbase=baseModelPath.EndsWith（@“zip”）
? SvfDocument.LoadFromZipFile（基本模型路径）
：SvfDocument.LoadFromSvfFile（baseModelPath）；
var svfincr=incrmodepath.EndsWith（@“zip”）
? SvfDocument.LoadFromZipFile（在模型路径中）
：SvfDocument.loadfromsffile（在模型路径中）；
var compareResult=CompareModel（svfbase，svfincr）；
var svfdiff=新的SvfDocument（）；
svfdiff.Model.Name=@“差异模型”；
svfdiff.Metadata=svfbase.Metadata；
var nodeUnmodified=svfdiff.Model.Children.CreateNode（）；
nodeUnmodified.Name=@“未修改”；
var nodeAdded=svfdiff.Model.Children.CreateNode（）；
nodeaded.Name=@“已添加”；
var nodeDeleted=svfdiff.Model.Children.CreateNode（）；
nodeDeleted.Name=@“已删除”；
var nodeModifiedBefore=svfdiff.Model.Children.CreateNode（）；
nodeModifiedBefore.Name=@“Modified Before”；
var nodeModifiedAfter=svfdiff.Model.Children.CreateNode（）；
nodeModifiedAfter.Name=@“修改后”；
枚举节点（节点=>
{
if（node.Children？.Count==0&&
node.Fragments？.Count>0&&
string.IsNullOrEmpty（node.ExternalId）==false）
{
if（compareResult.Unmodified.Remove（node.ExternalId））
{
ImportNodeWithPath（nodeUnmodified、node、svfbase.Model、matUnmodified）；
}
else if（compareResult.Deleted.Remove（node.ExternalId））
{
ImportNodeWithPath（nodeDeleted、node、svfbase.Model、matDelete）；
}
else if（compareResult.Modified.Contains（node.ExternalId））
{
var目标节点=
ImportNodeWithPath（nodeModifiedBefore、node、svfbase.Model、matModifiedBefore）；
targetNode.ExternalId+=@“\u Before”；
}
}
}，svfbase.Model）；
枚举节点（节点=>
{
if（node.Children？.Count==0&&
node.Fragments？.Count>0&&
string.IsNullOrEmpty（node.ExternalId）==false）
{
if（compareResult.Added.Remove（node.ExternalId））
{
ImportNodeWithPath（nodeaded、node、svfincr.Model、matAdd）；
}
else if（compareResult.Modified.Remove（node.ExternalId））
{
ImportNodeWithPath（nodeModifiedAfter、node、svfincr.Model、matModifiedAfter）；
}
}
}，svfincr.Model）；
svfdiff.SaveToFolder（diffModelPath，true）；
svfdiff.Dispose（）；
svfbase.Dispose（）；
svfincr.Dispose（）；
私有（未修改哈希集、添加哈希集、删除哈希集、修改哈希集）
比较模型（SvfDocument svfbase、SvfDocument svfincr）
{
var baseNodes=新字典（）；
枚举节点（节点=>
{
if（node.Children？.Count==0
&&node.Fragments？.Count>0
&&string.IsNullOrEmpty（node.ExternalId）==false）
{
baseNodes[node.ExternalId]=节点；
}
}，svfbase.Model）；
var elementsAdded=new HashSet（）；
var elementsUnmodified=new HashSet（）；
var elementsModified=new HashSet（）；
var elementsdelete=new HashSet（）；
svfincr。