Use LocalToGlobal logic for revit receive

Connectors/Revit/Speckle.Connectors.RevitShared/Operations/Receive/RevitHostObjectBuilder.cs

@@ -4,6 +4,7 @@
 using Speckle.Connectors.Revit.HostApp;
 using Speckle.Connectors.Utils.Builders;
 using Speckle.Connectors.Utils.Conversion;
+using Speckle.Connectors.Utils.Instances;
 using Speckle.Connectors.Utils.Operations.Receive;
 using Speckle.Converters.Common;
 using Speckle.Converters.RevitShared.Helpers;
@@ -20,6 +21,8 @@ internal sealed class RevitHostObjectBuilder : IHostObjectBuilder, IDisposable
   private readonly IRevitConversionContextStack _contextStack;
   private readonly GraphTraversal _traverseFunction;
   private readonly ITransactionManager _transactionManager;
+  private readonly ILocalToGlobalUnpacker _localToGlobalUnpacker;
+  private readonly LocalToGlobalConverterUtils _localToGlobalConverterUtils;
   private readonly RevitGroupBaker _groupManager;
   private readonly RevitMaterialBaker _materialBaker;
   private readonly ILogger<RevitHostObjectBuilder> _logger;
@@ -31,6 +34,8 @@ public RevitHostObjectBuilder(
     IRevitConversionContextStack contextStack,
     GraphTraversal traverseFunction,
     ITransactionManager transactionManager,
+    ILocalToGlobalUnpacker localToGlobalUnpacker,
+    LocalToGlobalConverterUtils localToGlobalConverterUtils,
     RevitGroupBaker groupManager,
     RevitMaterialBaker materialBaker,
     RootObjectUnpacker rootObjectUnpacker,
@@ -41,6 +46,8 @@ ILogger<RevitHostObjectBuilder> logger
     _contextStack = contextStack;
     _traverseFunction = traverseFunction;
     _transactionManager = transactionManager;
+    _localToGlobalUnpacker = localToGlobalUnpacker;
+    _localToGlobalConverterUtils = localToGlobalConverterUtils;
     _groupManager = groupManager;
     _materialBaker = materialBaker;
     _rootObjectUnpacker = rootObjectUnpacker;
@@ -70,6 +77,10 @@ CancellationToken cancellationToken
 
     // 1 - Unpack objects and proxies from root commit object
     var unpackedRoot = _rootObjectUnpacker.Unpack(rootObject);
+    var localToGlobalMaps = _localToGlobalUnpacker.Unpack(
+      unpackedRoot.DefinitionProxies,
+      unpackedRoot.ObjectsToConvert.ToList()
+    );
 
     using var activity = SpeckleActivityFactory.Start("Build");
 
@@ -88,7 +99,7 @@ CancellationToken cancellationToken
       }
     }
 
-    var conversionResults = BakeObjects(unpackedRoot.ObjectsToConvert, onOperationProgressed, cancellationToken);
+    var conversionResults = BakeObjects(localToGlobalMaps, onOperationProgressed, cancellationToken);
 
     using (var _ = SpeckleActivityFactory.Start("Commit"))
     {
@@ -122,48 +133,50 @@ CancellationToken cancellationToken
   }
 
   private HostObjectBuilderResult BakeObjects(
-    IEnumerable<TraversalContext> objectsGraph,
+    List<LocalToGlobalMap> localToGlobalMaps,
     Action<string, double?>? onOperationProgressed,
     CancellationToken cancellationToken
   )
   {
-    using (var _ = SpeckleActivityFactory.Start("BakeObjects"))
-    {
-      var conversionResults = new List<ReceiveConversionResult>();
-      var bakedObjectIds = new List<string>();
+    using var _ = SpeckleActivityFactory.Start("BakeObjects");
+    var conversionResults = new List<ReceiveConversionResult>();
+    var bakedObjectIds = new List<string>();
 
-      // is this a dumb idea?
-      var objectList = objectsGraph.ToList();
-      int count = 0;
+    // is this a dumb idea?
+    var objectList = localToGlobalMaps.ToList();
+    int count = 0;
 
-      foreach (TraversalContext tc in objectList)
+    foreach (LocalToGlobalMap localToGlobalMap in localToGlobalMaps)
+    {
+      cancellationToken.ThrowIfCancellationRequested();
+      try
       {
-        cancellationToken.ThrowIfCancellationRequested();
-        try
+        using var activity = SpeckleActivityFactory.Start("BakeObject");
+        var atomicObject = _localToGlobalConverterUtils.TransformObjects(
+          localToGlobalMap.AtomicObject,
+          localToGlobalMap.Matrix
+        );
+        var result = _converter.Convert(atomicObject);
+        onOperationProgressed?.Invoke("Converting", (double)++count / objectList.Count);
+
+        // Note: our current converter always returns a DS for now
+        if (result is DirectShape ds)
         {
-          using var activity = SpeckleActivityFactory.Start("BakeObject");
-          var result = _converter.Convert(tc.Current);
-          onOperationProgressed?.Invoke("Converting", (double)++count / objectList.Count);
-
-          // Note: our current converter always returns a DS for now
-          if (result is DirectShape ds)
-          {
-            bakedObjectIds.Add(ds.UniqueId.ToString());
-            _groupManager.AddToGroupMapping(tc, ds);
-          }
-          else
-          {
-            throw new SpeckleConversionException($"Failed to cast {result.GetType()} to Direct Shape.");
-          }
-          conversionResults.Add(new(Status.SUCCESS, tc.Current, ds.UniqueId, "Direct Shape"));
+          bakedObjectIds.Add(ds.UniqueId.ToString());
+          _groupManager.AddToGroupMapping(localToGlobalMap.TraversalContext, ds);
         }
-        catch (Exception ex) when (!ex.IsFatal())
+        else
         {
-          conversionResults.Add(new(Status.ERROR, tc.Current, null, null, ex));
+          throw new SpeckleConversionException($"Failed to cast {result.GetType()} to Direct Shape.");
         }
+        conversionResults.Add(new(Status.SUCCESS, atomicObject, ds.UniqueId, "Direct Shape"));
+      }
+      catch (Exception ex) when (!ex.IsFatal())
+      {
+        conversionResults.Add(new(Status.ERROR, localToGlobalMap.AtomicObject, null, null, ex));
       }
-      return new(bakedObjectIds, conversionResults);
     }
+    return new(bakedObjectIds, conversionResults);
   }
 
   public void Dispose()

Sdk/Speckle.Converters.Common.DependencyInjection/ContainerRegistration.cs

@@ -23,6 +23,7 @@ This will require consolidating across other connectors.
     builder.AddScoped<IFactory<IToHostTopLevelConverter>, Factory<IToHostTopLevelConverter>>();
     builder.AddScoped<IConverterResolver<IToHostTopLevelConverter>, ConverterResolver<IToHostTopLevelConverter>>();
 
+    builder.AddScoped<LocalToGlobalConverterUtils>();
     builder.AddScoped<IRootToHostConverter, ConverterWithFallback>();
     builder.AddScoped<ConverterWithoutFallback>(); //Register as self, only the `ConverterWithFallback` needs it
 

Sdk/Speckle.Converters.Common/LocalToGlobalConverterUtils.cs

@@ -0,0 +1,71 @@
+using Speckle.DoubleNumerics;
+using Speckle.Objects;
+using Speckle.Sdk.Models;
+
+namespace Speckle.Converters.Common;
+
+// POC: We could pass transformation matrices to converters by default and evaluate there instead as utils.
+public class LocalToGlobalConverterUtils
+{
+  private Vector3 TransformPt(Vector3 vector, Matrix4x4 matrix)
+  {
+    var divisor = matrix.M41 + matrix.M42 + matrix.M43 + matrix.M44;
+    var x = (vector.X * matrix.M11 + vector.Y * matrix.M12 + vector.Z * matrix.M13 + matrix.M14) / divisor;
+    var y = (vector.X * matrix.M21 + vector.Y * matrix.M22 + vector.Z * matrix.M23 + matrix.M24) / divisor;
+    var z = (vector.X * matrix.M31 + vector.Y * matrix.M32 + vector.Z * matrix.M33 + matrix.M34) / divisor;
+
+    return new Vector3(x, y, z);
+  }
+
+  // POC: This could move to converters instead handling all cases like this.
+  public Base TransformObjects(Base atomicObject, List<Matrix4x4> matrix)
+  {
+    if (matrix.Count == 0)
+    {
+      return atomicObject;
+    }
+
+    List<Speckle.Objects.Other.Transform> transforms = matrix
+      .Select(x => new Speckle.Objects.Other.Transform(x, "none"))
+      .ToList();
+
+    if (atomicObject is ITransformable c)
+    {
+      foreach (var transform in transforms)
+      {
+        c.TransformTo(transform, out ITransformable newObj);
+        c = newObj;
+      }
+
+      if (c is not Base)
+      {
+        throw new SpeckleConversionException(
+          $"Blocks transformation of type {atomicObject.speckle_type} did not return a valid object"
+        );
+      }
+
+      string id = atomicObject.id;
+      atomicObject = (Base)c;
+      atomicObject.id = id;
+
+      // .TransformTo only transfers typed properties, we need to add back the dynamic ones:
+      foreach (var prop in atomicObject.GetMembers(DynamicBaseMemberType.Dynamic))
+      {
+        if (prop.Value is not Base)
+        {
+          atomicObject[prop.Key] = prop.Value;
+        }
+        else
+        {
+          // TODO: add more granular warnings if needed that the property was skipped for blocks
+        }
+      }
+
+      return atomicObject;
+    }
+
+    throw new SpeckleConversionException(
+      $"{atomicObject.speckle_type} is not supported for local to global coordinate transformation"
+    );
+  }
+}