Implement image rotation

Author: hyazinthh

src/Aardvark.OpenCV.Tests/Tests/ImageTests.fs

@@ -14,6 +14,7 @@ module ``Image Processing Tests`` =
         let private randomValues : Type -> (unit -> obj) =
             LookupTable.lookup [
                 typeof<float32>, rnd.UniformFloat >> box
+                typeof<uint8>,   rnd.UniformUInt >> uint8 >> box
                 typeof<uint16>,  rnd.UniformUInt >> uint16 >> box
                 typeof<int32>,   rnd.UniformInt >> box
             ]
@@ -61,7 +62,7 @@ module ``Image Processing Tests`` =
         Aardvark.Init()
 
     [<Theory>]
-    let ``Scaling`` (filter: ImageInterpolation) (sub: bool) =
+    let ``Scale`` (filter: ImageInterpolation) (sub: bool) =
         let src = PixImage.generate<float32> Col.Format.RGBA sub
         let scaleFactor = V2d(0.2345, 1.6789)
 
@@ -72,7 +73,7 @@ module ``Image Processing Tests`` =
         psnr |> should be (greaterThan 20.0)
 
     [<Theory>]
-    let ``Remapping`` (sub: bool) =
+    let ``Remap`` (sub: bool) =
         let src = PixImage.generate<float32> Col.Format.RGBA sub
 
         let result =
@@ -100,7 +101,7 @@ module ``Image Processing Tests`` =
         psnr |> should be (greaterThan 20.0)
 
     [<Theory>]
-    let ``Remapping (border type)`` (borderType: ImageBorderType) (sub: bool) =
+    let ``Remap (border type)`` (borderType: ImageBorderType) (sub: bool) =
         let src = PixImage.generate<uint16> Col.Format.BGRA sub
         let border = [| 1us; 2us; 3us; 4us |]
 
@@ -137,4 +138,44 @@ module ``Image Processing Tests`` =
             | _ -> raise <| NotImplementedException()
 
         let psnr = PixImage.peakSignalToNoiseRatio result expected
-        psnr |> should equal infinity
+        psnr |> should equal infinity
+
+    [<Theory>]
+    let ``Rotate`` (resize: bool) (sub: bool) =
+        let src = PixImage.generate<uint8> Col.Format.BGRA sub
+        let angle = -Constant.PiTimesFour + rnd.UniformDouble() * Constant.PiTimesFour * 2.0
+
+        let rotated =
+            Aardvark.OpenCV.PixProcessor.Instance.Rotate(src, angle, resize, ImageInterpolation.Linear, border = [| 255uy; 0uy; 0uy; 255uy |])
+
+        let remapped =
+            let dstSize =
+                if resize then
+                    let srcSize = V2d src.Size.XY
+                    let cos = abs <| cos angle
+                    let sin = abs <| sin angle
+
+                    V2l(
+                        int64 (srcSize.X * cos + srcSize.Y * sin + 0.5),
+                        int64 (srcSize.X * sin + srcSize.Y * cos + 0.5)
+                    )
+
+                else
+                    src.SizeL
+
+            let mapX = Matrix<float32>(dstSize)
+            let mapY = Matrix<float32>(dstSize)
+
+            // Note: Positive angle -> clockwise rotation in the image coordinate system
+            let mat =
+                let srcCenter = v2f src.Size * 0.5f
+                let dstCenter = v2f dstSize * 0.5f
+                M33f.Translation srcCenter * M33f.RotationZ(float32 angle) * M33f.Translation -dstCenter
+
+            mapX.SetByCoord(fun x y -> V2l(x, y) |> v2f |> Mat.transformPos mat |> Vec.x) |> ignore
+            mapY.SetByCoord(fun x y -> V2l(x, y) |> v2f |> Mat.transformPos mat |> Vec.y) |> ignore
+
+            Aardvark.OpenCV.PixProcessor.Instance.Remap(src, mapX, mapY, ImageInterpolation.Linear, border = [| 255uy; 0uy; 0uy; 255uy |])
+
+        let psnr = PixImage.peakSignalToNoiseRatio rotated remapped
+        psnr |> should be (greaterThan 20.0)

src/Aardvark.OpenCV/ImageProcessing.cs

@@ -81,6 +81,20 @@ public static GCHandleDiposable ToMat<T>(this Matrix<T> matrix, MatType matType,
 
         public static GCHandleDiposable ToMat<T>(this Volume<T> volume, MatType matType, int elementSize, out CvMat result)
             => volume.Data.ToMat(volume.Size.XY, volume.Delta.XY, volume.FirstIndex, matType, elementSize, out result);
+
+        public static Scalar ToScalar<T>(this T[] color, Col.Format format)
+        {
+            var result = new Scalar();
+
+            if (color != null)
+            {
+                var order = format.ChannelOrder();
+                for (var i = 0; i < Fun.Min(color.Length, format.ChannelCount()); i++)
+                    result[i] = Convert.ToDouble(color[order[i]]);
+            }
+
+            return result;
+        }
     }
 
     #endregion
@@ -89,7 +103,7 @@ public sealed class PixProcessor : IPixProcessor
     {
         public string Name => "OpenCV";
 
-        public PixProcessorCaps Capabilities => PixProcessorCaps.Scale | PixProcessorCaps.Remap;
+        public PixProcessorCaps Capabilities => PixProcessorCaps.Scale | PixProcessorCaps.Rotate | PixProcessorCaps.Remap;
 
         [OnAardvarkInit]
         public static void Init()
@@ -135,10 +149,74 @@ public PixImage<T> Scale<T>(PixImage<T> image, V2d scaleFactor, ImageInterpolati
 
         #region Rotate
 
+        // TODO: Change the interface to accept T[] as border value
+        /// <inheritdoc cref="Rotate{T}(PixImage{T}, double, bool, ImageInterpolation, ImageBorderType, T)"/>
         public PixImage<T> Rotate<T>(PixImage<T> image, double angleInRadians, bool resize, ImageInterpolation interpolation,
                                      ImageBorderType borderType = ImageBorderType.Const,
-                                     T border = default)
-            => null;
+                                     T[] border = default)
+        {
+            var src = image.Volume;
+
+            if (!src.HasImageWindowLayout())
+            {
+                throw new ArgumentException($"Volume must be in image layout (Delta = {src.Delta}).");
+            }
+
+            var matType = typeof(T).ToMatType(image.ChannelCount);
+            var elementSize = typeof(T).GetCLRSize();
+
+            var srcCenter = image.Size.ToV2d() * 0.5;
+
+            // This already takes the handedness of the image coordinate system into account.
+            // See: https://docs.opencv.org/4.10.0/da/d54/group__imgproc__transform.html#gafbbc470ce83812914a70abfb604f4326
+            var rotMat =
+                Cv2.GetRotationMatrix2D(
+                    new Point2f((float)srcCenter.X, (float)srcCenter.Y),
+                    -angleInRadians.DegreesFromRadians(),
+                    1.0
+                );
+
+            var dstSize = image.Volume.Size;
+            if (resize)
+            {
+                // Compute bounds of rotated image
+                // See: https://stackoverflow.com/questions/3231176/how-to-get-size-of-a-rotated-rectangle
+                var cos = rotMat.At<double>(0, 0);
+                var sin = rotMat.At<double>(1, 0);
+                var cosAbs = cos.Abs();
+                var sinAbs = sin.Abs();
+                dstSize.X = (long)(image.Width * cosAbs + image.Height * sinAbs + 0.5);
+                dstSize.Y = (long)(image.Width * sinAbs + image.Height * cosAbs + 0.5);
+
+                // Adjust transformation matrix for new center
+                // We describe the inverse transformation (i.e. from dst to src).
+                // Shift by -dstCenter -> rotate CW -> shift by srcCenter.
+                // See: https://math.stackexchange.com/questions/2093314/rotation-matrix-of-rotation-around-a-point-other-than-the-origin
+                var dstCenter = dstSize.XY.ToV2d() * 0.5;
+                rotMat.At<double>(0, 2) = -dstCenter.X * cos + dstCenter.Y * sin + srcCenter.X;
+                rotMat.At<double>(1, 2) = -dstCenter.X * sin - dstCenter.Y * cos + srcCenter.Y;
+            }
+
+            var dst = dstSize.CreateImageVolume<T>();
+
+            using var _src = src.ToMat(matType, elementSize, out var srcMat);
+            using var _dst = dst.ToMat(matType, elementSize, out var dstMat);
+
+            Cv2.WarpAffine(
+                srcMat, dstMat, rotMat,
+                new Size((int)dst.SX, (int)dst.SY),
+                interpolation.ToInterpolationFlags(false) | InterpolationFlags.WarpInverseMap,
+                borderType.ToBorderTypes(),
+                (borderType == ImageBorderType.Const) ? border.ToScalar(image.Format) : new()
+            );
+
+            return new(image.Format, dst);
+        }
+
+        public PixImage<T> Rotate<T>(PixImage<T> image, double angleInRadians, bool resize, ImageInterpolation interpolation,
+                                     ImageBorderType borderType,
+                                     T border)
+            => Rotate(image, angleInRadians, resize, interpolation, borderType, new T[] { border, border, border, border });
 
         #endregion
 
@@ -173,20 +251,11 @@ public PixImage<T> Remap<T>(PixImage<T> image, Matrix<float> mapX, Matrix<float>
             using var _x = mapX.ToMat(MatType.CV_32FC1, 4, out var mapXMat);
             using var _y = mapY.ToMat(MatType.CV_32FC1, 4, out var mapYMat);
 
-            Scalar borderValue = new();
-            if (borderType == ImageBorderType.Const && border != null)
-            {
-                var order = image.Format.ChannelOrder();
-
-                for (var i = 0; i < Fun.Min(border.Length, 4); i++)
-                    borderValue[i] = Convert.ToDouble(border[order[i]]);
-            }
-
             Cv2.Remap(
                 srcMat, dstMat, mapXMat, mapYMat,
                 interpolation.ToInterpolationFlags(false),
                 borderType.ToBorderTypes(),
-                borderValue
+                (borderType == ImageBorderType.Const) ? border.ToScalar(image.Format) : new()
             );
 
             return new (image.Format, dst);