Add tests for new C# bindings (#5539)

* WIP: Add tests for new C# bindings

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* Fix output path

* Revert "Fix output path"

This reverts commit a763b5c.

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

* WIP: Update tests

Author: oitel

source/MRDotNet2Test/MRDotNet2Test.csproj

@@ -26,4 +26,8 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="NUnitLite" Version="4.4.0" />
+  </ItemGroup>
+
 </Project>

source/MRDotNet2Test/src/AffineXffTests.cs

@@ -0,0 +1,59 @@
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class AffineXfTests
+    {
+        [Test]
+        public void TestDefaultConstructor()
+        {
+            var a = new AffineXf3f();
+            Assert.That( a.A == new Matrix3f() );
+            Assert.That( a.B == new Vector3f() );
+        }
+
+        [Test]
+        public void TestConstructor()
+        {
+            var A = new Matrix3f( new Vector3f( 1, 2, 3 ), new Vector3f( 4, 5, 6 ), new Vector3f( 7, 8, 9 ) );
+            var b = new Vector3f( 10, 11, 12 );
+
+            var a = new AffineXf3f( A, b );
+            Assert.That( a.A == A );
+            Assert.That( a.B == b );
+        }
+
+        [Test]
+        public void TestLinearConstructor()
+        {
+            var A = new Matrix3f( new Vector3f( 1, 2, 3 ), new Vector3f( 4, 5, 6 ), new Vector3f( 7, 8, 9 ) );
+            var a = AffineXf3f.Linear( A );
+            Assert.That( a.A == A );
+            Assert.That( a.B == new Vector3f() );
+        }
+
+        [Test]
+        public void TestTranslationConstructor()
+        {
+            var b = new Vector3f( 10, 11, 12 );
+            var a = AffineXf3f.Translation( b );
+            Assert.That( a.A == new Matrix3f() );
+            Assert.That( a.B == b );
+        }
+
+        [Test]
+        public void TestMultiplication()
+        {
+            var A = new Matrix3f( new Vector3f( 1, 2, 3 ), new Vector3f( 4, 5, 6 ), new Vector3f( 7, 8, 9 ) );
+            var b = new Vector3f( 10, 11, 12 );
+            var xf = new AffineXf3f( A, b );
+
+            var res = xf * xf;
+            Assert.That( res.A == A * A );
+            Assert.That( res.B == A * b + b );
+        }
+
+    }
+}

source/MRDotNet2Test/src/BitSetTests.cs

@@ -0,0 +1,73 @@
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class BitSetTests
+    {
+        [Test]
+        public void TestDefaultConstructor()
+        {
+            var a = new BitSet();
+            Assert.That( a.Size(), Is.EqualTo(0) );
+        }
+
+        [Test]
+        public void TestConstructor()
+        {
+            var a = new BitSet( 20 );
+            Assert.That(a.Size(), Is.EqualTo(20));
+        }
+
+        [Test]
+        public void TestSet()
+        {
+            var a = new BitSet( 10 );
+            a.Set( 5 );
+            Assert.That( a.Test( 5 ) );
+            Assert.That( !a.Test( 4 ) );
+        }
+
+        [Test]
+        public void TestFindLast()
+        {
+            var a = new BitSet( 10 );
+            a.Set( 5 );
+            Assert.That( a.FindLast(), Is.EqualTo(5) );
+        }
+
+        [Test]
+        public void TestAutoResize()
+        {
+            var a = new BitSet();
+            a.AutoResizeSet(6);
+            Assert.That( a.Size() == 7 );
+        }
+
+        [Test]
+        public void TestSubtraction()
+        {
+            var a = new BitSet( 10 );
+            a.Set( 5 );
+            a.Set(6);
+            var b = new BitSet( 10 );
+            b.Set( 6 );
+            var c = a - b;
+            Assert.That( c.Test( 5 ) );
+            Assert.That( !c.Test( 6 ) );
+        }
+
+        [Test]
+        public void TestUnion()
+        {
+            var a = new BitSet( 10 );
+            a.Set( 5 );            
+            var b = new BitSet( 10 );
+            b.Set( 6 );
+            var c = a | b;
+            Assert.That( c.Test( 5 ) );
+            Assert.That( c.Test( 6 ) );
+        }
+    }
+}

source/MRDotNet2Test/src/BooleanTests.cs

@@ -0,0 +1,103 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class BooleanTests
+    {
+        [Test]
+        public void TestOperations()
+        {
+            const float PI = 3.14159265f;
+            Mesh meshA = MakeTorus(1.1f, 0.5f, 8, 8);
+            Mesh meshB = MakeTorus(1.0f, 0.2f, 8, 8);
+            meshB.Transform( AffineXf3f.Linear( Matrix3f.Rotation( Vector3f.PlusZ(), Vector3f.PlusY() ) ) );
+
+            const float shiftStep = 0.2f;
+            const float angleStep = PI;
+            var baseAxis = new Vector3f[] { Vector3f.PlusX(), Vector3f.PlusY(), Vector3f.PlusZ() };
+
+            for (int maskTrans = 0; maskTrans < 8; ++maskTrans)
+            {
+                for (int maskRot = 0; maskRot < 8; ++maskRot)
+                {
+                    for (float shift = 0.01f; shift < 0.2f; shift += shiftStep)
+                    {
+                        Vector3f shiftVec = new Vector3f();
+                        for (int i = 0; i < 3; ++i)
+                            if ( ( maskTrans & ( 1 << i ) ) > 0 )
+                                shiftVec += shift * baseAxis[i];
+
+                        for (float angle = PI * 0.01f; angle < PI * 7.0f / 18.0f; angle += angleStep)
+                        {
+                            Matrix3f rotation = new Matrix3f();
+                            for (int i = 0; i < 3; ++i)
+                                if ( ( maskRot & (1 << i) ) > 0 )
+                                    rotation = Matrix3f.Rotation( baseAxis[i], angle ) * rotation; 
+
+                            BooleanParameters parameters = new BooleanParameters();
+                            parameters.RigidB2A = AffineXf3f.Translation(shiftVec) * AffineXf3f.Linear(rotation);
+
+                            Assert.DoesNotThrow(() => Boolean(meshA, meshB, BooleanOperation.Union, parameters));
+                            Assert.DoesNotThrow(() => Boolean(meshA, meshB, BooleanOperation.Intersection, parameters));
+                        }
+                    }
+                }
+            }
+        }
+
+        [Test]
+        public void TestMapper()
+        {
+            Mesh meshA = MakeTorus(1.1f, 0.5f, 8, 8);
+            Mesh meshB = MakeTorus(1.0f, 0.2f, 8, 8);
+            meshB.Transform(AffineXf3f.Linear(Matrix3f.Rotation(Vector3f.PlusZ(), Vector3f.PlusY())));
+
+            var parameters = new BooleanParameters();
+            parameters.Mapper = new BooleanResultMapper();
+            var booleanResult = Boolean(meshA, meshB, BooleanOperation.Union, parameters);
+
+            var validPointsA = meshA.Topology.GetValidVerts();
+            var validPointsB = meshB.Topology.GetValidVerts();
+            var validFacesA = meshA.Topology.GetValidFaces();
+            var validFacesB = meshB.Topology.GetValidFaces();
+
+            var old2NewVerts = parameters.Mapper.GetMaps(BooleanResultMapper.MapObject.A).Old2newVerts;
+            var vMapA = parameters.Mapper.Map(validPointsA, BooleanResultMapper.MapObject.A);
+            var vMapB = parameters.Mapper.Map(validPointsB, BooleanResultMapper.MapObject.B);
+
+            Assert.That(vMapA.Size(), Is.EqualTo(60) );
+            Assert.That(vMapA.Count(), Is.EqualTo(60));
+            Assert.That(vMapB.Size(), Is.EqualTo(204) );
+            Assert.That(vMapB.Count(), Is.EqualTo(48));
+
+
+            var fMapA = parameters.Mapper.Map(validFacesA, BooleanResultMapper.MapObject.A);
+            var fMapB = parameters.Mapper.Map(validFacesB, BooleanResultMapper.MapObject.B);
+
+            Assert.That(fMapA.Size(), Is.EqualTo(224) );
+            Assert.That(fMapA.Count(), Is.EqualTo(224));
+            Assert.That(fMapB.Size(), Is.EqualTo(416) );
+            Assert.That(fMapB.Count(), Is.EqualTo(192));
+
+            var newFaces = parameters.Mapper.NewFaces();
+            Assert.That(newFaces.Size(), Is.EqualTo(416) );
+            Assert.That(newFaces.Count(), Is.EqualTo(252));
+
+            var mapsA = parameters.Mapper.GetMaps( BooleanResultMapper.MapObject.A );
+            Assert.That(!mapsA.Identity);
+            Assert.That( mapsA.Old2newVerts.Size(), Is.EqualTo(160) );
+            Assert.That( mapsA.Cut2newFaces.Size(), Is.EqualTo(348) );
+            Assert.That( mapsA.Cut2origin.Size(), Is.EqualTo(348) );
+
+            var mapsB = parameters.Mapper.GetMaps( BooleanResultMapper.MapObject.B );
+            Assert.That(!mapsB.Identity);
+            Assert.That( mapsB.Old2newVerts.Size(), Is.EqualTo(160) );
+            Assert.That( mapsB.Cut2newFaces.Size(), Is.EqualTo(384) );
+            Assert.That( mapsB.Cut2origin.Size(), Is.EqualTo(384) );
+        }
+    }
+}

source/MRDotNet2Test/src/Box3Tests.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{ 
+    [TestFixture]
+    internal class Box3Tests
+    {
+        [Test]
+        public void TestDefaultConstructor()
+        {
+            var box = new Box3f();
+            Assert.That(!box.Valid());
+        }
+
+        [Test]
+        public void TestBox()
+        {
+            var box = new Box3f(new Vector3f(1, 2, 3), new Vector3f(4, 5, 6));
+            Assert.That(box.Min.X == 1);
+            Assert.That(box.Min.Y == 2);
+            Assert.That(box.Min.Z == 3);
+
+            Assert.That(box.Max.X == 4);
+            Assert.That(box.Max.Y == 5);
+            Assert.That(box.Max.Z == 6);
+
+            var center = box.Center();
+            Assert.That(center.X == 2.5);
+            Assert.That(center.Y == 3.5);
+            Assert.That(center.Z == 4.5);
+
+            var size = box.Size();
+            Assert.That(size.X == 3);
+            Assert.That(size.Y == 3);
+            Assert.That(size.Z == 3);
+
+            float diagonal = box.Diagonal();
+            Assert.That(diagonal, Is.EqualTo(5.19).Within(0.01));
+
+            float volume = box.Volume();
+            Assert.That(volume, Is.EqualTo(27).Within(0.01));
+        }
+    }
+}

source/MRDotNet2Test/src/ConvexHullTests.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class ConvexHullTests
+    {
+        [Test]
+        public void TestConvexHull()
+        {
+            var meshA = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(-0.5f));
+            var meshB = MakeCube(Vector3f.Diagonal(1), Vector3f.Diagonal(0.0f));
+            var union = Boolean(meshA, meshB, BooleanOperation.Union);
+            var convexHull = MakeConvexHull(union.Mesh);
+
+            Assert.That(convexHull.Points.Size() == 14);
+        }
+    }
+}

source/MRDotNet2Test/src/DecimateTests.cs

@@ -0,0 +1,42 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class DecimateTests
+    {
+        [Test]
+        public void TestDecimate()
+        {
+            Mesh sphere = MakeSphere( new SphereParams( 0.5f, 30000 ) );
+
+            var savedRegion = new FaceBitSet((Const_BitSet)sphere.Topology.GetValidFaces());
+
+            var parameters = new DecimateSettings();
+            var region = new FaceBitSet((Const_BitSet)sphere.Topology.GetValidFaces());
+            if ( region is not null )
+                parameters.Region = region;
+
+            parameters.MaxTriangleAspectRatio = 80;
+
+            var decimateResult = DecimateMesh(sphere, parameters);
+            Assert.That(parameters.Region is not null && !parameters.Region.Equals( savedRegion ) );
+            Assert.That(decimateResult.FacesDeleted > 0);
+            Assert.That(decimateResult.VertsDeleted > 0);
+        }
+
+        [Test]
+        public void TestRemesh()
+        {
+            var sphere = MakeSphere( new SphereParams( 0.5f, 300 ) );
+            Assert.That(sphere.Topology.GetValidFaces().Count(), Is.EqualTo(596));
+            var parameters = new RemeshSettings();
+            parameters.TargetEdgeLen = 0.1f;
+            var remeshResult = Remesh(sphere, parameters);
+            Assert.That(sphere.Topology.GetValidFaces().Count(), Is.EqualTo(716));
+        }
+    }
+}

source/MRDotNet2Test/src/ExpandShrink.cs

@@ -0,0 +1,34 @@
+using NUnit.Framework;
+using static MR;
+
+namespace MRTest
+{
+    [TestFixture]
+    internal class ExpandShrinkTests
+    {
+        [Test]
+        public void TestExpandShrink()
+        {
+            var mesh = MakeSphere(new SphereParams(1.0f, 3000));
+            var region = Expand(mesh.Topology, new FaceId(0), 3);
+            Assert.That(region.Count, Is.EqualTo(75));
+            Expand(mesh.Topology, region, 3);
+            Assert.That(region.Count, Is.GreaterThan(75));
+            Shrink(mesh.Topology, region, 3);
+            Assert.That(region.Count, Is.EqualTo(75));
+        }
+
+        [Test]
+        public void TestExpandShrinkVerts()
+        {
+            var mesh = MakeSphere(new SphereParams(1.0f, 3000));
+            var region = Expand(mesh.Topology, new VertId(0), 3);
+            Assert.That(region.Count, Is.EqualTo(37));
+            Expand(mesh.Topology, region, 3);
+            Assert.That(region.Count, Is.GreaterThan(37));
+            Shrink(mesh.Topology, region, 3);
+            Assert.That(region.Count, Is.EqualTo(37));
+        }
+
+    }
+}