Use doubles in ResizeHelper

JimBobSquarePants · JimBobSquarePants · commit 2e3f3c1e390d · 2020-11-21T00:14:40.000Z
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeHelper.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeHelper.cs
@@ -47,12 +47,12 @@ public static (Size, Rectangle) CalculateTargetLocationAndBounds(Size sourceSize
             const int Min = 1;
             if (width == 0 && height > 0)
             {
-                width = (int)MathF.Max(Min, MathF.Round(sourceSize.Width * height / (float)sourceSize.Height));
+                width = (int)Math.Max(Min, Math.Round(sourceSize.Width * height / (double)sourceSize.Height));
             }
 
             if (height == 0 && width > 0)
             {
-                height = (int)MathF.Max(Min, MathF.Round(sourceSize.Height * width / (float)sourceSize.Width));
+                height = (int)Math.Max(Min, Math.Round(sourceSize.Height * width / (double)sourceSize.Width));
             }
 
             switch (options.Mode)
@@ -86,11 +86,11 @@ private static (Size, Rectangle) CalculateBoxPadRectangle(
             int sourceHeight = source.Height;
 
             // Fractional variants for preserving aspect ratio.
-            float percentHeight = MathF.Abs(height / (float)sourceHeight);
-            float percentWidth = MathF.Abs(width / (float)sourceWidth);
+            double percentHeight = Math.Abs(height / (double)sourceHeight);
+            double percentWidth = Math.Abs(width / (double)sourceWidth);
 
-            int boxPadHeight = height > 0 ? height : (int)MathF.Round(sourceHeight * percentWidth);
-            int boxPadWidth = width > 0 ? width : (int)MathF.Round(sourceWidth * percentHeight);
+            int boxPadHeight = height > 0 ? height : (int)Math.Round(sourceHeight * percentWidth);
+            int boxPadWidth = width > 0 ? width : (int)Math.Round(sourceWidth * percentHeight);
 
             // Only calculate if upscaling.
             if (sourceWidth < boxPadWidth && sourceHeight < boxPadHeight)
@@ -156,7 +156,7 @@ private static (Size, Rectangle) CalculateCropRectangle(
             int width,
             int height)
         {
-            float ratio;
+            double ratio;
             int sourceWidth = source.Width;
             int sourceHeight = source.Height;
 
@@ -166,26 +166,26 @@ private static (Size, Rectangle) CalculateCropRectangle(
             int targetHeight = height;
 
             // Fractional variants for preserving aspect ratio.
-            float percentHeight = MathF.Abs(height / (float)sourceHeight);
-            float percentWidth = MathF.Abs(width / (float)sourceWidth);
+            double percentHeight = Math.Abs(height / (double)sourceHeight);
+            double percentWidth = Math.Abs(width / (double)sourceWidth);
 
             if (percentHeight < percentWidth)
             {
                 ratio = percentWidth;
 
                 if (options.CenterCoordinates.HasValue)
                 {
-                    float center = -(ratio * sourceHeight) * options.CenterCoordinates.Value.Y;
-                    targetY = (int)MathF.Round(center + (height / 2F));
+                    double center = -(ratio * sourceHeight) * options.CenterCoordinates.Value.Y;
+                    targetY = (int)Math.Round(center + (height / 2F));
 
                     if (targetY > 0)
                     {
                         targetY = 0;
                     }
 
-                    if (targetY < (int)MathF.Round(height - (sourceHeight * ratio)))
+                    if (targetY < (int)Math.Round(height - (sourceHeight * ratio)))
                     {
-                        targetY = (int)MathF.Round(height - (sourceHeight * ratio));
+                        targetY = (int)Math.Round(height - (sourceHeight * ratio));
                     }
                 }
                 else
@@ -200,33 +200,33 @@ private static (Size, Rectangle) CalculateCropRectangle(
                         case AnchorPositionMode.Bottom:
                         case AnchorPositionMode.BottomLeft:
                         case AnchorPositionMode.BottomRight:
-                            targetY = (int)MathF.Round(height - (sourceHeight * ratio));
+                            targetY = (int)Math.Round(height - (sourceHeight * ratio));
                             break;
                         default:
-                            targetY = (int)MathF.Round((height - (sourceHeight * ratio)) / 2F);
+                            targetY = (int)Math.Round((height - (sourceHeight * ratio)) / 2F);
                             break;
                     }
                 }
 
-                targetHeight = (int)MathF.Ceiling(sourceHeight * percentWidth);
+                targetHeight = (int)Math.Ceiling(sourceHeight * percentWidth);
             }
             else
             {
                 ratio = percentHeight;
 
                 if (options.CenterCoordinates.HasValue)
                 {
-                    float center = -(ratio * sourceWidth) * options.CenterCoordinates.Value.X;
-                    targetX = (int)MathF.Round(center + (width / 2F));
+                    double center = -(ratio * sourceWidth) * options.CenterCoordinates.Value.X;
+                    targetX = (int)Math.Round(center + (width / 2F));
 
                     if (targetX > 0)
                     {
                         targetX = 0;
                     }
 
-                    if (targetX < (int)MathF.Round(width - (sourceWidth * ratio)))
+                    if (targetX < (int)Math.Round(width - (sourceWidth * ratio)))
                     {
-                        targetX = (int)MathF.Round(width - (sourceWidth * ratio));
+                        targetX = (int)Math.Round(width - (sourceWidth * ratio));
                     }
                 }
                 else
@@ -241,15 +241,15 @@ private static (Size, Rectangle) CalculateCropRectangle(
                         case AnchorPositionMode.Right:
                         case AnchorPositionMode.TopRight:
                         case AnchorPositionMode.BottomRight:
-                            targetX = (int)MathF.Round(width - (sourceWidth * ratio));
+                            targetX = (int)Math.Round(width - (sourceWidth * ratio));
                             break;
                         default:
-                            targetX = (int)MathF.Round((width - (sourceWidth * ratio)) / 2F);
+                            targetX = (int)Math.Round((width - (sourceWidth * ratio)) / 2F);
                             break;
                     }
                 }
 
-                targetWidth = (int)MathF.Ceiling(sourceWidth * percentHeight);
+                targetWidth = (int)Math.Ceiling(sourceWidth * percentHeight);
             }
 
             // Target image width and height can be different to the rectangle width and height.
@@ -265,20 +265,20 @@ private static (Size, Rectangle) CalculateMaxRectangle(
             int targetHeight = height;
 
             // Fractional variants for preserving aspect ratio.
-            float percentHeight = MathF.Abs(height / (float)source.Height);
-            float percentWidth = MathF.Abs(width / (float)source.Width);
+            double percentHeight = Math.Abs(height / (double)source.Height);
+            double percentWidth = Math.Abs(width / (double)source.Width);
 
-            // Integers must be cast to floats to get needed precision
-            float ratio = height / (float)width;
-            float sourceRatio = source.Height / (float)source.Width;
+            // Integers must be cast to doubles to get needed precision
+            double ratio = height / (double)width;
+            double sourceRatio = source.Height / (double)source.Width;
 
             if (sourceRatio < ratio)
             {
-                targetHeight = (int)MathF.Round(source.Height * percentWidth);
+                targetHeight = (int)Math.Round(source.Height * percentWidth);
             }
             else
             {
-                targetWidth = (int)MathF.Round(source.Width * percentHeight);
+                targetWidth = (int)Math.Round(source.Width * percentHeight);
             }
 
             // Replace the size to match the rectangle.
@@ -307,25 +307,25 @@ private static (Size, Rectangle) CalculateMinRectangle(
 
             if (widthDiff < heightDiff)
             {
-                float sourceRatio = (float)sourceHeight / sourceWidth;
-                targetHeight = (int)MathF.Round(width * sourceRatio);
+                double sourceRatio = (double)sourceHeight / sourceWidth;
+                targetHeight = (int)Math.Round(width * sourceRatio);
             }
             else if (widthDiff > heightDiff)
             {
-                float sourceRatioInverse = (float)sourceWidth / sourceHeight;
-                targetWidth = (int)MathF.Round(height * sourceRatioInverse);
+                double sourceRatioInverse = (double)sourceWidth / sourceHeight;
+                targetWidth = (int)Math.Round(height * sourceRatioInverse);
             }
             else
             {
                 if (height > width)
                 {
-                    float percentWidth = MathF.Abs(width / (float)sourceWidth);
-                    targetHeight = (int)MathF.Round(sourceHeight * percentWidth);
+                    double percentWidth = Math.Abs(width / (double)sourceWidth);
+                    targetHeight = (int)Math.Round(sourceHeight * percentWidth);
                 }
                 else
                 {
-                    float percentHeight = MathF.Abs(height / (float)sourceHeight);
-                    targetWidth = (int)MathF.Round(sourceWidth * percentHeight);
+                    double percentHeight = Math.Abs(height / (double)sourceHeight);
+                    targetWidth = (int)Math.Round(sourceWidth * percentHeight);
                 }
             }
 
@@ -339,7 +339,7 @@ private static (Size, Rectangle) CalculatePadRectangle(
             int width,
             int height)
         {
-            float ratio;
+            double ratio;
             int sourceWidth = sourceSize.Width;
             int sourceHeight = sourceSize.Height;
 
@@ -349,13 +349,13 @@ private static (Size, Rectangle) CalculatePadRectangle(
             int targetHeight = height;
 
             // Fractional variants for preserving aspect ratio.
-            float percentHeight = MathF.Abs(height / (float)sourceHeight);
-            float percentWidth = MathF.Abs(width / (float)sourceWidth);
+            double percentHeight = Math.Abs(height / (double)sourceHeight);
+            double percentWidth = Math.Abs(width / (double)sourceWidth);
 
             if (percentHeight < percentWidth)
             {
                 ratio = percentHeight;
-                targetWidth = (int)MathF.Round(sourceWidth * percentHeight);
+                targetWidth = (int)Math.Round(sourceWidth * percentHeight);
 
                 switch (options.Position)
                 {
@@ -367,17 +367,17 @@ private static (Size, Rectangle) CalculatePadRectangle(
                     case AnchorPositionMode.Right:
                     case AnchorPositionMode.TopRight:
                     case AnchorPositionMode.BottomRight:
-                        targetX = (int)MathF.Round(width - (sourceWidth * ratio));
+                        targetX = (int)Math.Round(width - (sourceWidth * ratio));
                         break;
                     default:
-                        targetX = (int)MathF.Round((width - (sourceWidth * ratio)) / 2F);
+                        targetX = (int)Math.Round((width - (sourceWidth * ratio)) / 2F);
                         break;
                 }
             }
             else
             {
                 ratio = percentWidth;
-                targetHeight = (int)MathF.Round(sourceHeight * percentWidth);
+                targetHeight = (int)Math.Round(sourceHeight * percentWidth);
 
                 switch (options.Position)
                 {
@@ -389,10 +389,10 @@ private static (Size, Rectangle) CalculatePadRectangle(
                     case AnchorPositionMode.Bottom:
                     case AnchorPositionMode.BottomLeft:
                     case AnchorPositionMode.BottomRight:
-                        targetY = (int)MathF.Round(height - (sourceHeight * ratio));
+                        targetY = (int)Math.Round(height - (sourceHeight * ratio));
                         break;
                     default:
-                        targetY = (int)MathF.Round((height - (sourceHeight * ratio)) / 2F);
+                        targetY = (int)Math.Round((height - (sourceHeight * ratio)) / 2F);
                         break;
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,12 @@ public static (Size, Rectangle) CalculateTargetLocationAndBounds(Size sourceSize`
`47`	`47`	`const int Min = 1;`
`48`	`48`	`if (width == 0 && height > 0)`
`49`	`49`	`{`
`50`		`- width = (int)MathF.Max(Min, MathF.Round(sourceSize.Width * height / (float)sourceSize.Height));`
	`50`	`+ width = (int)Math.Max(Min, Math.Round(sourceSize.Width * height / (double)sourceSize.Height));`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`if (height == 0 && width > 0)`
`54`	`54`	`{`
`55`		`- height = (int)MathF.Max(Min, MathF.Round(sourceSize.Height * width / (float)sourceSize.Width));`
	`55`	`+ height = (int)Math.Max(Min, Math.Round(sourceSize.Height * width / (double)sourceSize.Width));`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`switch (options.Mode)`
`@@ -86,11 +86,11 @@ private static (Size, Rectangle) CalculateBoxPadRectangle(`
`86`	`86`	`int sourceHeight = source.Height;`
`87`	`87`
`88`	`88`	`// Fractional variants for preserving aspect ratio.`
`89`		`- float percentHeight = MathF.Abs(height / (float)sourceHeight);`
`90`		`- float percentWidth = MathF.Abs(width / (float)sourceWidth);`
	`89`	`+ double percentHeight = Math.Abs(height / (double)sourceHeight);`
	`90`	`+ double percentWidth = Math.Abs(width / (double)sourceWidth);`
`91`	`91`
`92`		`- int boxPadHeight = height > 0 ? height : (int)MathF.Round(sourceHeight * percentWidth);`
`93`		`- int boxPadWidth = width > 0 ? width : (int)MathF.Round(sourceWidth * percentHeight);`
	`92`	`+ int boxPadHeight = height > 0 ? height : (int)Math.Round(sourceHeight * percentWidth);`
	`93`	`+ int boxPadWidth = width > 0 ? width : (int)Math.Round(sourceWidth * percentHeight);`
`94`	`94`
`95`	`95`	`// Only calculate if upscaling.`
`96`	`96`	`if (sourceWidth < boxPadWidth && sourceHeight < boxPadHeight)`
`@@ -156,7 +156,7 @@ private static (Size, Rectangle) CalculateCropRectangle(`
`156`	`156`	`int width,`
`157`	`157`	`int height)`
`158`	`158`	`{`
`159`		`- float ratio;`
	`159`	`+ double ratio;`
`160`	`160`	`int sourceWidth = source.Width;`
`161`	`161`	`int sourceHeight = source.Height;`
`162`	`162`
`@@ -166,26 +166,26 @@ private static (Size, Rectangle) CalculateCropRectangle(`
`166`	`166`	`int targetHeight = height;`
`167`	`167`
`168`	`168`	`// Fractional variants for preserving aspect ratio.`
`169`		`- float percentHeight = MathF.Abs(height / (float)sourceHeight);`
`170`		`- float percentWidth = MathF.Abs(width / (float)sourceWidth);`
	`169`	`+ double percentHeight = Math.Abs(height / (double)sourceHeight);`
	`170`	`+ double percentWidth = Math.Abs(width / (double)sourceWidth);`
`171`	`171`
`172`	`172`	`if (percentHeight < percentWidth)`
`173`	`173`	`{`
`174`	`174`	`ratio = percentWidth;`
`175`	`175`
`176`	`176`	`if (options.CenterCoordinates.HasValue)`
`177`	`177`	`{`
`178`		`- float center = -(ratio * sourceHeight) * options.CenterCoordinates.Value.Y;`
`179`		`- targetY = (int)MathF.Round(center + (height / 2F));`
	`178`	`+ double center = -(ratio * sourceHeight) * options.CenterCoordinates.Value.Y;`
	`179`	`+ targetY = (int)Math.Round(center + (height / 2F));`
`180`	`180`
`181`	`181`	`if (targetY > 0)`
`182`	`182`	`{`
`183`	`183`	`targetY = 0;`
`184`	`184`	`}`
`185`	`185`
`186`		`- if (targetY < (int)MathF.Round(height - (sourceHeight * ratio)))`
	`186`	`+ if (targetY < (int)Math.Round(height - (sourceHeight * ratio)))`
`187`	`187`	`{`
`188`		`- targetY = (int)MathF.Round(height - (sourceHeight * ratio));`
	`188`	`+ targetY = (int)Math.Round(height - (sourceHeight * ratio));`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`	`else`
`@@ -200,33 +200,33 @@ private static (Size, Rectangle) CalculateCropRectangle(`
`200`	`200`	`case AnchorPositionMode.Bottom:`
`201`	`201`	`case AnchorPositionMode.BottomLeft:`
`202`	`202`	`case AnchorPositionMode.BottomRight:`
`203`		`- targetY = (int)MathF.Round(height - (sourceHeight * ratio));`
	`203`	`+ targetY = (int)Math.Round(height - (sourceHeight * ratio));`
`204`	`204`	`break;`
`205`	`205`	`default:`
`206`		`- targetY = (int)MathF.Round((height - (sourceHeight * ratio)) / 2F);`
	`206`	`+ targetY = (int)Math.Round((height - (sourceHeight * ratio)) / 2F);`
`207`	`207`	`break;`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`- targetHeight = (int)MathF.Ceiling(sourceHeight * percentWidth);`
	`211`	`+ targetHeight = (int)Math.Ceiling(sourceHeight * percentWidth);`
`212`	`212`	`}`
`213`	`213`	`else`
`214`	`214`	`{`
`215`	`215`	`ratio = percentHeight;`
`216`	`216`
`217`	`217`	`if (options.CenterCoordinates.HasValue)`
`218`	`218`	`{`
`219`		`- float center = -(ratio * sourceWidth) * options.CenterCoordinates.Value.X;`
`220`		`- targetX = (int)MathF.Round(center + (width / 2F));`
	`219`	`+ double center = -(ratio * sourceWidth) * options.CenterCoordinates.Value.X;`
	`220`	`+ targetX = (int)Math.Round(center + (width / 2F));`
`221`	`221`
`222`	`222`	`if (targetX > 0)`
`223`	`223`	`{`
`224`	`224`	`targetX = 0;`
`225`	`225`	`}`
`226`	`226`
`227`		`- if (targetX < (int)MathF.Round(width - (sourceWidth * ratio)))`
	`227`	`+ if (targetX < (int)Math.Round(width - (sourceWidth * ratio)))`
`228`	`228`	`{`
`229`		`- targetX = (int)MathF.Round(width - (sourceWidth * ratio));`
	`229`	`+ targetX = (int)Math.Round(width - (sourceWidth * ratio));`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`	`else`
`@@ -241,15 +241,15 @@ private static (Size, Rectangle) CalculateCropRectangle(`
`241`	`241`	`case AnchorPositionMode.Right:`
`242`	`242`	`case AnchorPositionMode.TopRight:`
`243`	`243`	`case AnchorPositionMode.BottomRight:`
`244`		`- targetX = (int)MathF.Round(width - (sourceWidth * ratio));`
	`244`	`+ targetX = (int)Math.Round(width - (sourceWidth * ratio));`
`245`	`245`	`break;`
`246`	`246`	`default:`
`247`		`- targetX = (int)MathF.Round((width - (sourceWidth * ratio)) / 2F);`
	`247`	`+ targetX = (int)Math.Round((width - (sourceWidth * ratio)) / 2F);`
`248`	`248`	`break;`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
`252`		`- targetWidth = (int)MathF.Ceiling(sourceWidth * percentHeight);`
	`252`	`+ targetWidth = (int)Math.Ceiling(sourceWidth * percentHeight);`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`// Target image width and height can be different to the rectangle width and height.`
`@@ -265,20 +265,20 @@ private static (Size, Rectangle) CalculateMaxRectangle(`
`265`	`265`	`int targetHeight = height;`
`266`	`266`
`267`	`267`	`// Fractional variants for preserving aspect ratio.`
`268`		`- float percentHeight = MathF.Abs(height / (float)source.Height);`
`269`		`- float percentWidth = MathF.Abs(width / (float)source.Width);`
	`268`	`+ double percentHeight = Math.Abs(height / (double)source.Height);`
	`269`	`+ double percentWidth = Math.Abs(width / (double)source.Width);`
`270`	`270`
`271`		`- // Integers must be cast to floats to get needed precision`
`272`		`- float ratio = height / (float)width;`
`273`		`- float sourceRatio = source.Height / (float)source.Width;`
	`271`	`+ // Integers must be cast to doubles to get needed precision`
	`272`	`+ double ratio = height / (double)width;`
	`273`	`+ double sourceRatio = source.Height / (double)source.Width;`
`274`	`274`
`275`	`275`	`if (sourceRatio < ratio)`
`276`	`276`	`{`
`277`		`- targetHeight = (int)MathF.Round(source.Height * percentWidth);`
	`277`	`+ targetHeight = (int)Math.Round(source.Height * percentWidth);`
`278`	`278`	`}`
`279`	`279`	`else`
`280`	`280`	`{`
`281`		`- targetWidth = (int)MathF.Round(source.Width * percentHeight);`
	`281`	`+ targetWidth = (int)Math.Round(source.Width * percentHeight);`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`// Replace the size to match the rectangle.`
`@@ -307,25 +307,25 @@ private static (Size, Rectangle) CalculateMinRectangle(`
`307`	`307`
`308`	`308`	`if (widthDiff < heightDiff)`
`309`	`309`	`{`
`310`		`- float sourceRatio = (float)sourceHeight / sourceWidth;`
`311`		`- targetHeight = (int)MathF.Round(width * sourceRatio);`
	`310`	`+ double sourceRatio = (double)sourceHeight / sourceWidth;`
	`311`	`+ targetHeight = (int)Math.Round(width * sourceRatio);`
`312`	`312`	`}`
`313`	`313`	`else if (widthDiff > heightDiff)`
`314`	`314`	`{`
`315`		`- float sourceRatioInverse = (float)sourceWidth / sourceHeight;`
`316`		`- targetWidth = (int)MathF.Round(height * sourceRatioInverse);`
	`315`	`+ double sourceRatioInverse = (double)sourceWidth / sourceHeight;`
	`316`	`+ targetWidth = (int)Math.Round(height * sourceRatioInverse);`
`317`	`317`	`}`
`318`	`318`	`else`
`319`	`319`	`{`
`320`	`320`	`if (height > width)`
`321`	`321`	`{`
`322`		`- float percentWidth = MathF.Abs(width / (float)sourceWidth);`
`323`		`- targetHeight = (int)MathF.Round(sourceHeight * percentWidth);`
	`322`	`+ double percentWidth = Math.Abs(width / (double)sourceWidth);`
	`323`	`+ targetHeight = (int)Math.Round(sourceHeight * percentWidth);`
`324`	`324`	`}`
`325`	`325`	`else`
`326`	`326`	`{`
`327`		`- float percentHeight = MathF.Abs(height / (float)sourceHeight);`
`328`		`- targetWidth = (int)MathF.Round(sourceWidth * percentHeight);`
	`327`	`+ double percentHeight = Math.Abs(height / (double)sourceHeight);`
	`328`	`+ targetWidth = (int)Math.Round(sourceWidth * percentHeight);`
`329`	`329`	`}`
`330`	`330`	`}`
`331`	`331`
`@@ -339,7 +339,7 @@ private static (Size, Rectangle) CalculatePadRectangle(`
`339`	`339`	`int width,`
`340`	`340`	`int height)`
`341`	`341`	`{`
`342`		`- float ratio;`
	`342`	`+ double ratio;`
`343`	`343`	`int sourceWidth = sourceSize.Width;`
`344`	`344`	`int sourceHeight = sourceSize.Height;`
`345`	`345`
`@@ -349,13 +349,13 @@ private static (Size, Rectangle) CalculatePadRectangle(`
`349`	`349`	`int targetHeight = height;`
`350`	`350`
`351`	`351`	`// Fractional variants for preserving aspect ratio.`
`352`		`- float percentHeight = MathF.Abs(height / (float)sourceHeight);`
`353`		`- float percentWidth = MathF.Abs(width / (float)sourceWidth);`
	`352`	`+ double percentHeight = Math.Abs(height / (double)sourceHeight);`
	`353`	`+ double percentWidth = Math.Abs(width / (double)sourceWidth);`
`354`	`354`
`355`	`355`	`if (percentHeight < percentWidth)`
`356`	`356`	`{`
`357`	`357`	`ratio = percentHeight;`
`358`		`- targetWidth = (int)MathF.Round(sourceWidth * percentHeight);`
	`358`	`+ targetWidth = (int)Math.Round(sourceWidth * percentHeight);`
`359`	`359`
`360`	`360`	`switch (options.Position)`
`361`	`361`	`{`
`@@ -367,17 +367,17 @@ private static (Size, Rectangle) CalculatePadRectangle(`
`367`	`367`	`case AnchorPositionMode.Right:`
`368`	`368`	`case AnchorPositionMode.TopRight:`
`369`	`369`	`case AnchorPositionMode.BottomRight:`
`370`		`- targetX = (int)MathF.Round(width - (sourceWidth * ratio));`
	`370`	`+ targetX = (int)Math.Round(width - (sourceWidth * ratio));`
`371`	`371`	`break;`
`372`	`372`	`default:`
`373`		`- targetX = (int)MathF.Round((width - (sourceWidth * ratio)) / 2F);`
	`373`	`+ targetX = (int)Math.Round((width - (sourceWidth * ratio)) / 2F);`
`374`	`374`	`break;`
`375`	`375`	`}`
`376`	`376`	`}`
`377`	`377`	`else`
`378`	`378`	`{`
`379`	`379`	`ratio = percentWidth;`
`380`		`- targetHeight = (int)MathF.Round(sourceHeight * percentWidth);`
	`380`	`+ targetHeight = (int)Math.Round(sourceHeight * percentWidth);`
`381`	`381`
`382`	`382`	`switch (options.Position)`
`383`	`383`	`{`
`@@ -389,10 +389,10 @@ private static (Size, Rectangle) CalculatePadRectangle(`
`389`	`389`	`case AnchorPositionMode.Bottom:`
`390`	`390`	`case AnchorPositionMode.BottomLeft:`
`391`	`391`	`case AnchorPositionMode.BottomRight:`
`392`		`- targetY = (int)MathF.Round(height - (sourceHeight * ratio));`
	`392`	`+ targetY = (int)Math.Round(height - (sourceHeight * ratio));`
`393`	`393`	`break;`
`394`	`394`	`default:`
`395`		`- targetY = (int)MathF.Round((height - (sourceHeight * ratio)) / 2F);`
	`395`	`+ targetY = (int)Math.Round((height - (sourceHeight * ratio)) / 2F);`
`396`	`396`	`break;`
`397`	`397`	`}`
`398`	`398`	`}`