DYN-6489 Dynamo Zoom Extents behavior has changed

src/DynamoCoreWpf/ViewModels/Watch3D/HelixWatch3DViewModel.cs

@@ -3006,27 +3006,23 @@ internal static Rect3D ToRect3D(this BoundingBox bounds, double minRectSize = 0.
         /// <returns>A <see cref="BoundingBox"/> object encapsulating the geometry.</returns>
         internal static BoundingBox Bounds(this GeometryModel3D geom, float defaultBoundsSize = 5.0f)
         {
-            if (geom.Geometry.Positions == null || geom.Geometry.Positions.Count == 0)
-            {
-                return new BoundingBox();
-            }
+            var bounds = geom.Bounds;
 
-            if (geom.Geometry.Positions.Count > 1)
+            if(Math.Abs(bounds.Size.LengthSquared()) < defaultBoundsSize * defaultBoundsSize * 3)
             {
-                return BoundingBox.FromPoints(geom.Geometry.Positions.ToArray());
+                var pos = bounds.Center();
+                var min = pos + new Vector3(-defaultBoundsSize, -defaultBoundsSize, -defaultBoundsSize);
+                var max = pos + new Vector3(defaultBoundsSize, defaultBoundsSize, defaultBoundsSize);
+                return new BoundingBox(min, max);
             }
 
-            var pos = geom.Geometry.Positions.First();
-            var min = pos + new Vector3(-defaultBoundsSize, -defaultBoundsSize, -defaultBoundsSize);
-            var max = pos + new Vector3(defaultBoundsSize, defaultBoundsSize, defaultBoundsSize);
-            return new BoundingBox(min, max);
+            return bounds;
         }
 
         public static Vector3 Center(this BoundingBox bounds)
         {
             return (bounds.Maximum + bounds.Minimum)/2;
         }
-
     }
 
     internal static class Vector3Extensions

src/DynamoCoreWpf/Views/Core/DynamoView.xaml.cs

@@ -1360,7 +1360,6 @@ private void DynamoView_Loaded(object sender, EventArgs e)
             BackgroundPreview = new Watch3DView { Name = BackgroundPreviewName };
             background_grid.Children.Add(BackgroundPreview);
             BackgroundPreview.DataContext = dynamoViewModel.BackgroundPreviewViewModel;
-            BackgroundPreview.Margin = new System.Windows.Thickness(0, 20, 0, 0);
             var vizBinding = new Binding
             {
                 Source = dynamoViewModel.BackgroundPreviewViewModel,

src/DynamoCoreWpf/Views/Preview/Watch3DView.xaml.cs

@@ -173,17 +173,136 @@ private void ViewLoadedHandler(object sender, RoutedEventArgs e)
         private void ViewModel_RequestZoomToFit(BoundingBox bounds)
         {
             var prevcamDir = watch_view.Camera.LookDirection;
-            watch_view.ZoomExtents(bounds.ToRect3D(.05));
-            //if after a zoom the camera is in an undefined position or view direction, reset it.
-            if(watch_view.Camera.Position.ToVector3().IsUndefined() || 
-                watch_view.Camera.LookDirection.ToVector3().IsUndefined() || 
-                watch_view.Camera.LookDirection.Length == 0)
+            if (watch_view.Camera is HelixToolkit.Wpf.SharpDX.PerspectiveCamera perspectiveCam)
             {
-                watch_view.Camera.Position = prevCamera;
-                watch_view.Camera.LookDirection = prevcamDir;
+                //Todo, Call the equivalent method in Helix on adoption of next release.
+                ZoomExtents(perspectiveCam, (float)(watch_view.ActualWidth / watch_view.ActualHeight), bounds, out var pos,
+                    out var look, out var up);
+                perspectiveCam.AnimateTo(pos.ToPoint3D(), look.ToVector3D(), up.ToVector3D(), 0);
+
+                //if after a zoom the camera is in an undefined position or view direction, reset it.
+                if (watch_view.Camera.Position.ToVector3().IsUndefined() ||
+                    watch_view.Camera.LookDirection.ToVector3().IsUndefined() ||
+                    watch_view.Camera.LookDirection.Length == 0)
+                {
+                    watch_view.Camera.Position = prevCamera;
+                    watch_view.Camera.LookDirection = prevcamDir;
+                }
+            }
+        }
+
+        #region ZoomExtents
+
+        //This implementation is found in the current dev branch of Helix-Toolkit (https://github.com/helix-toolkit/helix-toolkit/tree/develop) with the assumption it will be included in the 2.25.0 release
+        //The PR including these changes "Re-implementing zoom extents in sharpdx versions" is found here -> https://github.com/helix-toolkit/helix-toolkit/pull/2003
+        //Specifically the code included here is located in https://github.com/holance/helix-toolkit/blob/develop/Source/HelixToolkit.SharpDX.Shared/Extensions/CameraCoreExtensions.cs in this commit:
+        //https://github.com/holance/helix-toolkit/commit/660c85ff2218eb318f810dd682986d1816c5ece5
+        //This implementation is adjusted to remove the instance method pattern.
+        //This section can be removed when we adopt the next release of helix-toolkit and call the ZoomExtents() directly.
+
+        private static void ZoomExtents(HelixToolkit.Wpf.SharpDX.PerspectiveCamera camera, float aspectRatio, BoundingBox boundingBox, out Vector3 position, out Vector3 lookDir, out Vector3 upDir)
+        {
+            var cameraDir = Vector3.Normalize(camera.LookDirection.ToVector3());
+            var cameraUp = Vector3.Normalize(camera.UpDirection.ToVector3());
+            var cameraRight = Vector3.Cross(cameraDir, cameraUp);
+            cameraUp = Vector3.Cross(cameraRight, cameraDir);
+
+            var corners = boundingBox.GetCorners();
+
+            var frustum = new BoundingFrustum(camera.CreateViewMatrix() * camera.CreateProjectionMatrix(aspectRatio));
+            var leftNormal = -frustum.Left.Normal;
+            var rightNormal = -frustum.Right.Normal;
+            var topNormal = -frustum.Top.Normal;
+            var bottomNormal = -frustum.Bottom.Normal;
+
+            int leftMostPoint = -1, rightMostPoint = -1, topMostPoint = -1, bottomMostPoint = -1;
+            for (int i = 0; i < corners.Length; i++)
+            {
+                if (leftMostPoint < 0 && IsOutermostPointInDirection(i, ref leftNormal, corners))
+                {
+                    leftMostPoint = i;
+                }
+                if (rightMostPoint < 0 && IsOutermostPointInDirection(i, ref rightNormal, corners))
+                {
+                    rightMostPoint = i;
+                }
+                if (topMostPoint < 0 && IsOutermostPointInDirection(i, ref topNormal, corners))
+                {
+                    topMostPoint = i;
+                }
+                if (bottomMostPoint < 0 && IsOutermostPointInDirection(i, ref bottomNormal, corners))
+                {
+                    bottomMostPoint = i;
+                }
+            }
+
+            var plane1 = new Plane(corners[leftMostPoint], leftNormal);
+            var plane2 = new Plane(corners[rightMostPoint], rightNormal);
+            PlaneIntersectsPlane(ref plane1, ref plane2, out var horizontalIntersection);
+            plane1 = new Plane(corners[topMostPoint], topNormal);
+            plane2 = new Plane(corners[bottomMostPoint], bottomNormal);
+            PlaneIntersectsPlane(ref plane1, ref plane2, out var verticalIntersection);
+            FindClosestPointsOnTwoLines(ref horizontalIntersection, ref verticalIntersection, out var closestPointLine1, out var closestPointLine2);
+            position = Vector3.Dot(closestPointLine1 - closestPointLine2, cameraDir) < 0 ? closestPointLine1 : closestPointLine2;
+            upDir = cameraUp;
+            var boundPlane = new Plane(boundingBox.Center, cameraDir);
+            var lookRay = new Ray(position, cameraDir);
+            boundPlane.Intersects(ref lookRay, out float dist);
+            lookDir = cameraDir * dist;
+        }
+
+        private static bool IsOutermostPointInDirection(int pointIndex, ref Vector3 direction, Vector3[] corners)
+        {
+            Vector3 point = corners[pointIndex];
+            for (int i = 0; i < corners.Length; i++)
+            {
+                if (i != pointIndex && Vector3.Dot(direction, corners[i] - point) > 0)
+                    return false;
             }
+
+            return true;
         }
 
+        // Credit: http://wiki.unity3d.com/index.php/3d_Math_functions
+        // Returns the edge points of the closest line segment between 2 lines
+        private static void FindClosestPointsOnTwoLines(ref Ray line1, ref Ray line2, out Vector3 closestPointLine1, out Vector3 closestPointLine2)
+        {
+            Vector3 line1Direction = line1.Direction;
+            Vector3 line2Direction = line2.Direction;
+
+            float a = Vector3.Dot(line1Direction, line1Direction);
+            float b = Vector3.Dot(line1Direction, line2Direction);
+            float e = Vector3.Dot(line2Direction, line2Direction);
+
+            float d = a * e - b * b;
+
+            Vector3 r = line1.Position - line2.Position;
+            float c = Vector3.Dot(line1Direction, r);
+            float f = Vector3.Dot(line2Direction, r);
+
+            float s = (b * f - c * e) / d;
+            float t = (a * f - c * b) / d;
+
+            closestPointLine1 = line1.Position + line1Direction * s;
+            closestPointLine2 = line2.Position + line2Direction * t;
+        }
+
+        private static bool PlaneIntersectsPlane(ref Plane p1, ref Plane p2, out Ray intersection)
+        {
+            var dir = Vector3.Cross(p1.Normal, p2.Normal);
+            float det = Vector3.Dot(dir, dir);
+            if (Math.Abs(det) > float.Epsilon)
+            {
+                var p = (Vector3.Cross(dir, p2.Normal) * p1.D + Vector3.Cross(p1.Normal, dir) * p2.D) / det;
+                intersection = new Ray(p, dir);
+                return true;
+            }
+            intersection = default;
+            return false;
+        }
+
+        #endregion
+
         private void RequestViewRefreshHandler()
         {
             View.InvalidateRender();