Implement scaling (WIP)

Author: hyazinthh

paket.dependencies

@@ -14,6 +14,12 @@ group Test
     storage: none
     source https://api.nuget.org/v3/index.json
 
-    nuget NUnit                    ~> 3.14.0
-    nuget NUnit3TestAdapter        ~> 4.5.0
-    nuget Microsoft.NET.Test.Sdk   ~> 17.9.0
+    nuget FSharp.Core                      ~> 8.0.0
+
+    nuget Aardvark.PixImage.ImageSharp     ~> 2.0.1
+
+    nuget NUnit                            ~> 3.14.0
+    nuget NUnit3TestAdapter                ~> 4.5.0
+    nuget Microsoft.NET.Test.Sdk           ~> 17.9.0
+
+    nuget BenchmarkDotNet                  ~> 0.14.0

paket.lock

@@ -3,13 +3,22 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
+    <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <OutputPath>..\..\bin\Debug</OutputPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
     <OutputPath>..\..\bin\Release</OutputPath>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Benchmarks\ImageBench.fs" />
+    <Compile Include="Tests\ClusteringTests.fs" />
+    <Compile Include="Tests\FittingTests.fs" />
+    <Compile Include="Tests\ImageTests.fs" />
+    <Compile Include="Program.fs" />
+    <None Include="paket.references" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Aardvark.OpenCV\Aardvark.OpenCV.csproj" />
   </ItemGroup>

src/Aardvark.OpenCV.Tests/Aardvark.OpenCV.Tests.csproj renamed to src/Aardvark.OpenCV.Tests/Aardvark.OpenCV.Tests.fsproj

@@ -0,0 +1,35 @@
+namespace Aardvark.OpenCV.Benchmarks
+
+open Aardvark.Base
+open Aardvark.OpenCV
+open BenchmarkDotNet.Attributes
+
+module ``Image Processing Benchmarks`` =
+
+    type Scaling() =
+
+        [<DefaultValue; Params(128, 1024, 2048, 4096)>]
+        val mutable Size : int
+
+        [<DefaultValue; Params(ImageInterpolation.Linear, ImageInterpolation.Cubic, ImageInterpolation.Lanczos)>]
+        val mutable Interpolation : ImageInterpolation
+
+        let mutable image = null
+
+        let scaleFactor = V2d(0.234, 0.894)
+
+        [<GlobalSetup>]
+        member x.Setup() =
+            Aardvark.Init()
+            let rnd = RandomSystem 0
+            image <- new PixImage<float32>(Col.Format.RGBA, x.Size, x.Size)
+            image.Volume.SetByIndex(ignore >> rnd.UniformFloat) |> ignore
+
+        [<Benchmark(Description = "Aardvark (Tensors)", Baseline = true)>]
+        member x.AardvarkTensors() =
+            let volume = image.Volume.Scaled(scaleFactor, x.Interpolation)
+            PixImage<float32>(image.Format, volume)
+
+        [<Benchmark>]
+        member x.OpenCV() =
+            TensorExtensions.ScaledOpenCV(image, scaleFactor, x.Interpolation)

src/Aardvark.OpenCV.Tests/Benchmarks/ImageBench.fs

@@ -0,0 +1,20 @@
+namespace Aardvark.OpenCV.Benchmarks
+
+open System.Reflection
+open BenchmarkDotNet.Running;
+open BenchmarkDotNet.Configs
+open BenchmarkDotNet.Jobs
+open BenchmarkDotNet.Toolchains
+
+module Program =
+
+    [<EntryPoint>]
+    let main argv =
+
+        let cfg =
+            let job = Job.ShortRun.WithToolchain(InProcess.Emit.InProcessEmitToolchain.Instance)
+            ManualConfig.Create(DefaultConfig.Instance).WithOptions(ConfigOptions.DisableOptimizationsValidator).AddJob(job)
+
+        BenchmarkSwitcher.FromAssembly(Assembly.GetExecutingAssembly()).Run(argv, cfg) |> ignore
+
+        0

src/Aardvark.OpenCV.Tests/ClusteringTests.cs

@@ -0,0 +1,38 @@
+using Aardvark.Base;
+using BenchmarkDotNet.Attributes;
+
+namespace Aardvark.OpenCV.Tests
+{
+    public class Scaling
+    {
+        [Params(128, 1024, 2048, 4096)]
+        public int Size;
+
+        [Params(ImageInterpolation.Linear, ImageInterpolation.Cubic)]
+        public ImageInterpolation Interpolation;
+
+        private PixImage<float> _image;
+
+        private readonly V2d _scaleFactor = new (0.234, 0.894);
+
+        [GlobalSetup]
+        public void Init()
+        {
+            Aardvark.Base.Aardvark.Init();
+            var rnd = new RandomSystem(0);
+            _image = new PixImage<float>(Col.Format.RGBA, new V2i(Size, Size));
+            _image.Volume.SetByIndex((_) => rnd.UniformFloat());
+        }
+
+        [Benchmark(Description = "Aardvark (Tensors)", Baseline = true)]
+        public PixImage<float> AardvarkTensors()
+        {
+            var volume = Aardvark.Base.TensorExtensions.Scaled(_image.Volume, _scaleFactor, Interpolation);
+            return new PixImage<float>(_image.Format, volume);
+        }
+
+        [Benchmark]
+        public PixImage<float> OpenCV()
+            => TensorExtensions.ScaledOpenCV(_image, _scaleFactor, Interpolation);
+    }
+}

src/Aardvark.OpenCV.Tests/FittingTests.cs

@@ -0,0 +1,25 @@
+namespace Aardvark.OpenCV.Tests
+
+open Aardvark.Base
+open Aardvark.OpenCV
+open NUnit.Framework
+
+module ``Clustering Tests`` =
+
+    let private vec value =
+        Vector<float32> [| value; value; value |]
+
+    [<SetUp>]
+    let init() =
+        Aardvark.Init()
+
+    [<Test>]
+    let ``K-means``() =
+        let data = [| vec -1.2f; vec -1.3f; vec -1.4f; vec 2.3f; vec 2.4f |]
+
+        let mutable clusters = Array.empty
+        let mutable centers = Array.empty
+        OpenCVKMeansClustering.ClusterKMeans(data, 2, 1, false, &clusters, &centers);
+
+        Assert.AreEqual([| 0; 0; 0; 1; 1 |], clusters);
+

src/Aardvark.OpenCV.Tests/Program.fs

@@ -0,0 +1,17 @@
+namespace Aardvark.OpenCV.Tests
+
+open Aardvark.Base
+open Aardvark.OpenCV
+open NUnit.Framework
+
+module ``Fitting Tests`` =
+
+    [<SetUp>]
+    let init() =
+        Aardvark.Init()
+
+    [<Test>]
+    let ``Plane3d least squares``() =
+        let data = [| V3d(1.0, 2.0, -1.0); V3d(5.0, 4.0, -1.0); V3d(23.0, 100.0, -1.0) |]
+        let plane = data.FitPlane3dLeastSquares();
+        Assert.AreEqual(Plane3d(V3d.ZAxis, -1), plane);