Add support for round corners if there is no animations (#451)

* Add support for round corners if there is no animations

Author: aborziak-ms

source/Animatables/Vector2.cs

@@ -67,5 +67,9 @@ public Vector2(double x, double y)
 
         /// <inheritdoc/>
         public override string ToString() => $"{{{X},{Y}}}";
+
+        public double Length() => Math.Sqrt((X * X) + (Y * Y));
+
+        public Vector2 Normalized() => this / Length();
     }
 }

source/LottieToWinComp/Paths.cs

@@ -117,6 +117,7 @@ public static CompositionShape TranslatePathContent(ShapeContext context, Path p
             geometry.SetDescription(context, () => $"{path.Name}.PathGeometry");
 
             var pathData = Optimizer.TrimAnimatable(context, Optimizer.GetOptimized(context, path.Data));
+            pathData = TranslateRoundCorners(context, pathData);
 
             var compositionSpriteShape = TranslatePath(context, pathData, GetPathFillType(context.Fill));
             compositionSpriteShape.SetDescription(context, () => path.Name);
@@ -129,6 +130,21 @@ public static CompositionShape TranslatePathContent(ShapeContext context, Path p
             return compositionSpriteShape;
         }
 
+        private static TrimmedAnimatable<PathGeometry> TranslateRoundCorners(ShapeContext context, TrimmedAnimatable<PathGeometry> pathGeometry)
+        {
+            if (context.RoundCorners.Radius.IsAlways(0) || context.RoundCorners.Radius.IsAnimated)
+            {
+                return pathGeometry;
+            }
+
+            if (!pathGeometry.IsAnimated)
+            {
+                return new TrimmedAnimatable<PathGeometry>(pathGeometry.Context, MakeRoundCorners(pathGeometry.InitialValue, context.RoundCorners.Radius.InitialValue));
+            }
+
+            return pathGeometry;
+        }
+
         /// <summary>
         /// Groups multiple Shapes into a D2D geometry group.
         /// </summary>
@@ -410,5 +426,152 @@ sealed class StateCache
             public Dictionary<(PathGeometry, ShapeFill.PathFillType, bool), CompositionPath> CompositionPaths { get; }
                 = new Dictionary<(PathGeometry, ShapeFill.PathFillType, bool), CompositionPath>();
         }
+
+        static BezierSegment MakeCubicBezier(Vector2 cp0, Vector2 cp1, Vector2 cp2)
+        {
+            // This is similar to converting QudraticBezier to CubicBezier, but instead of
+            // coefficiet 2/3 we are using 0.55 . This coefficient was found experimentally by comparing
+            // images from AfterEffects and LottieViewer.
+            return new BezierSegment(cp0, cp0 + ((cp1 - cp0) * 0.55), cp2 + ((cp1 - cp2) * 0.55), cp2);
+        }
+
+        // The way this function works is it detects if two segments form a corner (if they do not have smooth connection)
+        // Then it duplicates this point (shared by two segments) and moves newly generated points in different directions
+        // for "radius" pixels along the segment.
+        // After that we are joining both new points with a bezier curve to make the corner look rounded.
+        //
+        // There are 3 possible cases:
+        // 1. When the segment is curved from both sides, then we can just keep it as it is
+        // 2. When the segment is not curved from both sides, then we can make two rounded corners, from both ends.
+        // 3. When the segment curved from one side (begin or end) we are making only one rounded corner.
+        //
+        // In order to make a rounded corner we also need two points on segments next to the current segment.
+        // In this algortihm we are processing segments one by one, and passing one point from one segment to another,
+        // so that currently processed segment can create rounded corner using this point, and pass new point
+        // to the next segment, so that it can create next rounded corner and so on.
+        static PathGeometry MakeRoundCorners(PathGeometry pathGeometry, double radius)
+        {
+            // There is no corners if we have less than two segments.
+            if (pathGeometry.BezierSegments.Count < 2)
+            {
+                return pathGeometry;
+            }
+
+            var count = pathGeometry.BezierSegments.Count;
+
+            // We treat array of segments as a circular array, so that first and last elements are adjacent.
+            Func<int, int> getCircularIndex = (i) => ((i % count) + count) % count;
+
+            // Initial value does not matter, it is guranteed that it will be reassigned before use.
+            Vector2 prevControlPoint = Vector2.Zero;
+
+            List<BezierSegment> resultSegments = new List<BezierSegment>();
+
+            // If path is closed we are processing last segment at the beggining to get
+            // proper value for prevControlPoint for first segment, so we are starting from -1.
+            for (var i = pathGeometry.IsClosed ? -1 : 0; i < count; i++)
+            {
+                var segment = pathGeometry.BezierSegments[getCircularIndex(i)];
+                var prevSegment = pathGeometry.BezierSegments[getCircularIndex(i - 1)];
+                var nextSegment = pathGeometry.BezierSegments[getCircularIndex(i + 1)];
+
+                // We can make rounded corner at the beggining of the segment if we do not have any curvature
+                // at point ControlPoint0 except if path is not closed and this segment is the first
+                bool canRoundBegin =
+                    segment.ControlPoint0 == segment.ControlPoint1 &&
+                    prevSegment.ControlPoint2 == prevSegment.ControlPoint3 &&
+                    (getCircularIndex(i) != 0 || pathGeometry.IsClosed);
+
+                // We can make rounded corner at the end of the segment if we do not have any curvature
+                // at point ControlPoint3 except if path is not closed and this segment is the last
+                bool canRoundEnd = segment.ControlPoint2 == segment.ControlPoint3 &&
+                    nextSegment.ControlPoint0 == nextSegment.ControlPoint1 &&
+                    (getCircularIndex(i) != count - 1 || pathGeometry.IsClosed);
+
+                if (!canRoundBegin && !canRoundEnd)
+                {
+                    // Both ends are curved, just adding current segment to the result.
+                    resultSegments.Add(segment);
+                }
+                else if (canRoundBegin && canRoundEnd)
+                {
+                    // Both ends are not curved, so we can make them rounded.
+                    var cp0cp3 = segment.ControlPoint3 - segment.ControlPoint0;
+                    var length = cp0cp3.Length();
+                    var radiusVector = cp0cp3.Normalized() * radius;
+
+                    // We are moving both ends of the segment, towards the center for "radius" pixels
+                    // Example:
+                    // Segment of length 13: p0-------------p1
+                    // #1 Radius 2:          --p0---------p1--
+                    // #2 Radius 8:          ------p0-p1------
+                    // In case #2 points has changed their relative order along the segment, so in this case
+                    // if doubled radius is greater than the length, we are moving both point to the middle:
+                    //                       -------p01------- (p0 = p1)
+                    // Case #1:
+                    Vector2 point0 = segment.ControlPoint0 + radiusVector;
+                    Vector2 point1 = segment.ControlPoint3 - radiusVector;
+
+                    // If doubled radius is greater than length, then both points collapse into
+                    // one point right in the middle of the segment.
+                    // Case #2:
+                    if (length <= 2 * radius)
+                    {
+                        point0 = point1 = (segment.ControlPoint0 + segment.ControlPoint3) * 0.5;
+                    }
+
+                    // Rounded corner.
+                    resultSegments.Add(MakeCubicBezier(prevControlPoint, segment.ControlPoint0, point0));
+
+                    // Straigt line that connects point0 and point1.
+                    if (point0 != point1)
+                    {
+                        resultSegments.Add(new BezierSegment(point0, point0, point1, point1));
+                    }
+
+                    // In the next iteration we will use this to make the next rounded corner.
+                    prevControlPoint = point1;
+                }
+                else if (canRoundBegin)
+                {
+                    // Second end is curved, so we can make only one rounded corner.
+                    var cp0cp2 = segment.ControlPoint2 - segment.ControlPoint0;
+                    var length = cp0cp2.Length();
+                    var radiusVector = cp0cp2.Normalized() * radius;
+
+                    Vector2 point = length > radius ? segment.ControlPoint0 + radiusVector : segment.ControlPoint2;
+
+                    // Rounded corner.
+                    resultSegments.Add(MakeCubicBezier(prevControlPoint, segment.ControlPoint0, point));
+
+                    // Adusted bezier segment.
+                    resultSegments.Add(MakeCubicBezier(point, segment.ControlPoint2, segment.ControlPoint3));
+                }
+                else if (canRoundEnd)
+                {
+                    // Second end is curved, so we can make only one rounded corner.
+                    var cp3cp1 = segment.ControlPoint1 - segment.ControlPoint3;
+                    var length = cp3cp1.Length();
+                    var radiusVector = cp3cp1.Normalized() * radius;
+
+                    Vector2 point = length > radius ? segment.ControlPoint3 + radiusVector : segment.ControlPoint1;
+
+                    // Adjusted bezier segment.
+                    resultSegments.Add(MakeCubicBezier(segment.ControlPoint0, segment.ControlPoint1, point));
+
+                    // In the next iteration we will use this to make the next rounded corner.
+                    prevControlPoint = point;
+                }
+
+                if (i == -1)
+                {
+                    // If i = -1 then it was special pre-pass to get the valid value of prevControlPoint,
+                    // all generated segments should be ignored.
+                    resultSegments.Clear();
+                }
+            }
+
+            return new PathGeometry(new Sequence<BezierSegment>(resultSegments), pathGeometry.IsClosed);
+        }
     }
 }