Respect EXIF orientation when resizing

Author: JimBobSquarePants

src/ImageSharp.Web/Processors/ResizeWebProcessor.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using Microsoft.Extensions.Logging;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.ImageSharp.Web.Commands;
@@ -41,10 +42,15 @@ public class ResizeWebProcessor : IImageWebProcessor
         public const string Sampler = "rsampler";
 
         /// <summary>
-        /// The command constant for the resize sampler.
+        /// The command constant for the resize anchor position.
         /// </summary>
         public const string Anchor = "ranchor";
 
+        /// <summary>
+        /// The command constant for the resize orientation handling mode.
+        /// </summary>
+        public const string Orient = "rorient";
+
         /// <summary>
         /// The command constant for the resize compand mode.
         /// </summary>
@@ -59,7 +65,8 @@ private static readonly IEnumerable<string> ResizeCommands
                 Mode,
                 Sampler,
                 Anchor,
-                Compand
+                Compand,
+                Orient
             };
 
         /// <inheritdoc/>
@@ -73,7 +80,7 @@ public FormattedImage Process(
             CommandParser parser,
             CultureInfo culture)
         {
-            ResizeOptions options = GetResizeOptions(commands, parser, culture);
+            ResizeOptions options = GetResizeOptions(image.Image, commands, parser, culture);
 
             if (options != null)
             {
@@ -84,6 +91,7 @@ public FormattedImage Process(
         }
 
         private static ResizeOptions GetResizeOptions(
+            Image image,
             CommandCollection commands,
             CommandParser parser,
             CultureInfo culture)
@@ -93,7 +101,7 @@ private static ResizeOptions GetResizeOptions(
                 return null;
             }
 
-            Size size = ParseSize(commands, parser, culture);
+            Size size = ParseSize(image, commands, parser, culture);
 
             if (size.Width <= 0 && size.Height <= 0)
             {
@@ -116,15 +124,38 @@ private static ResizeOptions GetResizeOptions(
         }
 
         private static Size ParseSize(
+            Image image,
             CommandCollection commands,
             CommandParser parser,
             CultureInfo culture)
         {
             // The command parser will reject negative numbers as it clamps values to ranges.
-            uint width = parser.ParseValue<uint>(commands.GetValueOrDefault(Width), culture);
-            uint height = parser.ParseValue<uint>(commands.GetValueOrDefault(Height), culture);
+            int width = (int)parser.ParseValue<uint>(commands.GetValueOrDefault(Width), culture);
+            int height = (int)parser.ParseValue<uint>(commands.GetValueOrDefault(Height), culture);
+
+            // Browsers now implement 'image-orientation: from-image' by default.
+            // https://developer.mozilla.org/en-US/docs/web/css/image-orientation
+            // This makes orientation handling confusing for users who expect images to be resized in accordance
+            // to what they observe rather than pure (and correct) methods.
+            //
+            // To accomodate this we parse the dimensions to use based upon decoded EXIF orientation values, switching
+            // the width/height parameters when images are rotated (not flipped).
+            // We default to 'true' for EXIF orientation handling. By passing 'false' it can be turned off.
+            if (!commands.Contains(Orient) || parser.ParseValue<bool>(commands.GetValueOrDefault(Orient), culture))
+            {
+                if (image.Metadata.ExifProfile != null)
+                {
+                    IExifValue<ushort> orientation = image.Metadata.ExifProfile.GetValue(ExifTag.Orientation);
+                    return orientation.Value switch
+                    {
+                        // LeftTop, RightTop, RightBottom, LeftBottom
+                        5 or 6 or 7 or 8 => new Size(height, width),
+                        _ => new Size(width, height),
+                    };
+                }
+            }
 
-            return new Size((int)width, (int)height);
+            return new Size(width, height);
         }
 
         private static PointF? GetCenter(
@@ -166,40 +197,25 @@ private static IResampler GetSampler(CommandCollection commands)
 
             if (sampler != null)
             {
-                switch (sampler.ToLowerInvariant())
+                // No need to do a case test here. Parsed commands are automatically converted to lowercase.
+                return sampler switch
                 {
-                    case "nearest":
-                    case "nearestneighbor":
-                        return KnownResamplers.NearestNeighbor;
-                    case "box":
-                        return KnownResamplers.Box;
-                    case "mitchell":
-                    case "mitchellnetravali":
-                        return KnownResamplers.MitchellNetravali;
-                    case "catmull":
-                    case "catmullrom":
-                        return KnownResamplers.CatmullRom;
-                    case "lanczos2":
-                        return KnownResamplers.Lanczos2;
-                    case "lanczos3":
-                        return KnownResamplers.Lanczos3;
-                    case "lanczos5":
-                        return KnownResamplers.Lanczos5;
-                    case "lanczos8":
-                        return KnownResamplers.Lanczos8;
-                    case "welch":
-                        return KnownResamplers.Welch;
-                    case "robidoux":
-                        return KnownResamplers.Robidoux;
-                    case "robidouxsharp":
-                        return KnownResamplers.RobidouxSharp;
-                    case "spline":
-                        return KnownResamplers.Spline;
-                    case "triangle":
-                        return KnownResamplers.Triangle;
-                    case "hermite":
-                        return KnownResamplers.Hermite;
-                }
+                    "nearest" or "nearestneighbor" => KnownResamplers.NearestNeighbor,
+                    "box" => KnownResamplers.Box,
+                    "mitchell" or "mitchellnetravali" => KnownResamplers.MitchellNetravali,
+                    "catmull" or "catmullrom" => KnownResamplers.CatmullRom,
+                    "lanczos2" => KnownResamplers.Lanczos2,
+                    "lanczos3" => KnownResamplers.Lanczos3,
+                    "lanczos5" => KnownResamplers.Lanczos5,
+                    "lanczos8" => KnownResamplers.Lanczos8,
+                    "welch" => KnownResamplers.Welch,
+                    "robidoux" => KnownResamplers.Robidoux,
+                    "robidouxsharp" => KnownResamplers.RobidouxSharp,
+                    "spline" => KnownResamplers.Spline,
+                    "triangle" => KnownResamplers.Triangle,
+                    "hermite" => KnownResamplers.Hermite,
+                    _ => KnownResamplers.Bicubic,
+                };
             }
 
             return KnownResamplers.Bicubic;

tests/ImageSharp.Web.Tests/Processors/ResizeWebProcessorTests.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
 using SixLabors.ImageSharp.Web.Commands;
@@ -50,7 +51,9 @@ public void ResizeWebProcessor_UpdatesSize(string resampler)
 
             CommandCollection commands = new()
             {
-                { new(ResizeWebProcessor.Sampler, resampler) },
+                // We only need to do this for the unit tests.
+                // Commands generated via URL will automatically be converted to lowecase
+                { new(ResizeWebProcessor.Sampler, resampler.ToLowerInvariant()) },
                 { new(ResizeWebProcessor.Width, width.ToString()) },
                 { new(ResizeWebProcessor.Height, height.ToString()) },
                 { new(ResizeWebProcessor.Xy, "0,0") },
@@ -64,5 +67,104 @@ public void ResizeWebProcessor_UpdatesSize(string resampler)
             Assert.Equal(width, image.Width);
             Assert.Equal(height, image.Height);
         }
+
+        [Theory]
+        [InlineData(0, false)]
+        [InlineData(1, false)]
+        [InlineData(2, false)]
+        [InlineData(3, false)]
+        [InlineData(4, false)]
+        [InlineData(5, true)]
+        [InlineData(6, true)]
+        [InlineData(7, true)]
+        [InlineData(8, true)]
+        public void ResizeWebProcessor_RespectsOrientation(ushort orientation, bool rotated)
+        {
+            const int width = 4;
+            const int height = 6;
+
+            var converters = new List<ICommandConverter>
+            {
+                new IntegralNumberConverter<uint>(),
+                new ArrayConverter<float>(),
+                new EnumConverter(),
+                new SimpleCommandConverter<bool>(),
+                new SimpleCommandConverter<float>()
+            };
+
+            var parser = new CommandParser(converters);
+            CultureInfo culture = CultureInfo.InvariantCulture;
+
+            CommandCollection commands = new()
+            {
+                { new(ResizeWebProcessor.Width, width.ToString()) },
+                { new(ResizeWebProcessor.Height, height.ToString()) },
+                { new(ResizeWebProcessor.Mode, nameof(ResizeMode.Stretch)) }
+            };
+
+            using var image = new Image<Rgba32>(1, 1);
+            image.Metadata.ExifProfile = new();
+            image.Metadata.ExifProfile.SetValue(ExifTag.Orientation, orientation);
+
+            using var formatted = new FormattedImage(image, PngFormat.Instance);
+            new ResizeWebProcessor().Process(formatted, null, commands, parser, culture);
+
+            if (rotated)
+            {
+                Assert.Equal(height, image.Width);
+                Assert.Equal(width, image.Height);
+            }
+            else
+            {
+                Assert.Equal(width, image.Width);
+                Assert.Equal(height, image.Height);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        [InlineData(7)]
+        [InlineData(8)]
+        public void ResizeWebProcessor_CanIgnoreOrientation(ushort orientation)
+        {
+            const int width = 4;
+            const int height = 6;
+
+            var converters = new List<ICommandConverter>
+            {
+                new IntegralNumberConverter<uint>(),
+                new ArrayConverter<float>(),
+                new EnumConverter(),
+                new SimpleCommandConverter<bool>(),
+                new SimpleCommandConverter<float>()
+            };
+
+            var parser = new CommandParser(converters);
+            CultureInfo culture = CultureInfo.InvariantCulture;
+
+            CommandCollection commands = new()
+            {
+                { new(ResizeWebProcessor.Width, width.ToString()) },
+                { new(ResizeWebProcessor.Height, height.ToString()) },
+                { new(ResizeWebProcessor.Mode, nameof(ResizeMode.Stretch)) },
+                { new(ResizeWebProcessor.Orient, bool.FalseString) }
+            };
+
+            using var image = new Image<Rgba32>(1, 1);
+            image.Metadata.ExifProfile = new();
+            image.Metadata.ExifProfile.SetValue(ExifTag.Orientation, orientation);
+
+            using var formatted = new FormattedImage(image, PngFormat.Instance);
+            new ResizeWebProcessor().Process(formatted, null, commands, parser, culture);
+
+            Assert.Equal(width, image.Width);
+            Assert.Equal(height, image.Height);
+        }
     }
 }