Implementation of priority sectors

CadRevealComposer.Tests/Operations/CameraPositioningTests.cs

@@ -32,5 +32,5 @@ public void InitialCameraPositionLongestAxisY()
     }
 
     private record TestPrimitiveWithBoundingBox(Vector3 Min, Vector3 Max)
-        : APrimitive(int.MaxValue, Color.Red, new BoundingBox(Min, Max));
+        : APrimitive(int.MaxValue, Color.Red, new BoundingBox(Min, Max), 0, null);
 }

CadRevealComposer.Tests/Operations/ExteriorSplitterTests.cs

@@ -25,7 +25,7 @@ public void ExteriorTest()
     /// <summary>
     /// The exterior splitter uses axis aligned bounding box for Box primitive. All other data is irrelevant.
     /// </summary>
-    private static Box CreateBoxCenteredInOrigin(ulong treeIndex, float boxSize)
+    private static Box CreateBoxCenteredInOrigin(uint treeIndex, float boxSize)
     {
         return new Box(
             Matrix4x4.Identity,

CadRevealComposer.Tests/Operations/Splitting/PrioritySectorSplitterTests.cs

@@ -0,0 +1,84 @@
+namespace CadRevealComposer.Tests.Operations.Splitting;
+
+using System.Drawing;
+using System.Numerics;
+using CadRevealComposer.Operations.SectorSplitting;
+using IdProviders;
+using Primitives;
+
+[TestFixture]
+public class PrioritySectorSplitterTests
+{
+    const string DisciplinePipe = "PIPE";
+    const string DisciplineCable = "CABLE";
+
+    [Test]
+    public void OnePipeAndOneCablePrimitive_SplitIntoSectors_ShouldResultInRootSectorAndOneSectorForEachDiscipline()
+    {
+        APrimitive[] primitives = [CreatePrimitive(0f, 0, DisciplinePipe), CreatePrimitive(2f, 1, DisciplineCable)];
+
+        var splitter = new PrioritySectorSplitter();
+        var sectors = splitter.SplitIntoSectors(primitives, new SequentialIdGenerator()).ToArray();
+
+        Assert.That(sectors, Has.Length.EqualTo(3));
+    }
+
+    [Test]
+    public void FivePrimitivesWhereTwoAreFarAway_SplitIntoSectors_ShouldResultInRootSectorAndOneSectorWithThree()
+    {
+        var primitives = PositionsToPrimitives([-40f, -10f, 0f, 10f, 40f]);
+
+        var splitter = new PrioritySectorSplitter();
+        var sectors = splitter.SplitIntoSectors(primitives, new SequentialIdGenerator()).ToArray();
+
+        Assert.That(sectors, Has.Length.EqualTo(2));
+        Assert.That(sectors[1].Geometries, Has.Length.EqualTo(3));
+    }
+
+    [Test]
+    public void ManyPrimitivesToExceedByteSizeBudget_SplitIntoSectors_ShouldResultMoreThanOneNonRootSectors()
+    {
+        const int count = 1000;
+        var positions = Enumerable
+            .Range(0, count + 1)
+            .Select(i =>
+            {
+                var factor = i / (double)count;
+                var value = (-1 + 2 * factor) * 10;
+
+                return (float)(Math.Sign(value) * Math.Pow(value, 2));
+            });
+
+        var primitives = PositionsToPrimitives(positions);
+
+        var splitter = new PrioritySectorSplitter();
+        var sectors = splitter.SplitIntoSectors(primitives, new SequentialIdGenerator()).ToArray();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(sectors, Has.Length.EqualTo(3));
+            Assert.That(sectors[1].Geometries, Has.Length.EqualTo(569));
+            Assert.That(sectors[2].Geometries, Has.Length.EqualTo(432));
+        });
+    }
+
+    private static APrimitive[] PositionsToPrimitives(IEnumerable<float> positions) =>
+        positions
+            .Select((position, index) => CreatePrimitive(position, (uint)index, DisciplinePipe))
+            .ToArray<APrimitive>();
+
+    private static Box CreatePrimitive(float xPosition, uint treeIndex, string discipline)
+    {
+        var position = new Vector3(xPosition, 0, 0);
+
+        return new Box(
+            Matrix4x4.CreateTranslation(xPosition + 0.5f, 0, 0),
+            treeIndex,
+            Color.Black,
+            new BoundingBox(position, position + Vector3.One)
+        )
+        {
+            Discipline = discipline
+        };
+    }
+}

CadRevealComposer.Tests/Operations/Splitting/PrioritySplittingUtilsTests.cs

@@ -0,0 +1,104 @@
+#nullable enable
+namespace CadRevealComposer.Tests.Operations.Splitting;
+
+using System.Drawing;
+using System.Numerics;
+using CadRevealComposer.Operations.SectorSplitting;
+using Primitives;
+
+[TestFixture]
+public class PrioritySplittingUtilsTests
+{
+    const string DisciplinePipe = "PIPE";
+    const string DisciplineCable = "CABLE";
+
+    [Test]
+    public void CadRevealNodesWithVariousConfigurations_SetPriorityForHighlightSplittingWithMutation_VerifyCorrectlyMutated()
+    {
+        const uint treeIndexDisciplinePipeWithTag = 0;
+        const uint treeIndexDisciplinePipeMissingTag = 1;
+        const uint treeIndexDisciplineCableWithTag = 2;
+        const uint treeIndexDisciplineCableMissingTag = 3;
+
+        CadRevealNode[] nodes =
+        [
+            CreateCadRevealNode(treeIndexDisciplinePipeWithTag, DisciplinePipe, true),
+            CreateCadRevealNode(treeIndexDisciplinePipeMissingTag, DisciplinePipe, false),
+            CreateCadRevealNode(treeIndexDisciplineCableWithTag, DisciplineCable, true),
+            CreateCadRevealNode(treeIndexDisciplineCableMissingTag, DisciplineCable, false),
+        ];
+
+        PrioritySplittingUtils.SetPriorityForHighlightSplittingWithMutation(nodes);
+
+        AssertDisciplineAndPriority(nodes[treeIndexDisciplinePipeWithTag].Geometries[0], DisciplinePipe, 1);
+        AssertDisciplineAndPriority(nodes[treeIndexDisciplinePipeMissingTag].Geometries[0], DisciplinePipe, 0);
+        AssertDisciplineAndPriority(nodes[treeIndexDisciplineCableWithTag].Geometries[0], null, 0);
+        AssertDisciplineAndPriority(nodes[treeIndexDisciplineCableMissingTag].Geometries[0], null, 0);
+        return;
+
+        void AssertDisciplineAndPriority(APrimitive primitive, string? expectedDiscipline, int expectedPriority)
+        {
+            Assert.Multiple(() =>
+            {
+                Assert.That(primitive.Discipline, Is.EqualTo(expectedDiscipline));
+                Assert.That(primitive.Priority, Is.EqualTo(expectedPriority));
+            });
+        }
+    }
+
+    [Test]
+    public void ThreePrimitiveGroupsWithDifferentCombinationsOfSizes_ConvertPrimitiveGroupsToNodes_ShouldReturnNodesWithCorrectNumberOfPrimitives()
+    {
+        const float smallPrimitiveSize = 0.01f;
+        const float largePrimitiveSize = 1.0f;
+        const uint treeIndexOneLargeOneSmallPrimitive = 0;
+        const uint treeIndexTwoSmallPrimitives = 1;
+        const uint treeIndexTwoLargePrimitives = 2;
+
+        APrimitive[] primitives =
+        [
+            CreatePrimitive(smallPrimitiveSize, treeIndexOneLargeOneSmallPrimitive, DisciplinePipe),
+            CreatePrimitive(largePrimitiveSize, treeIndexOneLargeOneSmallPrimitive, DisciplinePipe),
+            CreatePrimitive(smallPrimitiveSize, treeIndexTwoSmallPrimitives, DisciplinePipe),
+            CreatePrimitive(smallPrimitiveSize, treeIndexTwoSmallPrimitives, DisciplinePipe),
+            CreatePrimitive(largePrimitiveSize, treeIndexTwoLargePrimitives, DisciplinePipe),
+            CreatePrimitive(largePrimitiveSize, treeIndexTwoLargePrimitives, DisciplinePipe),
+        ];
+
+        var geometryGroups = primitives.GroupBy(primitive => primitive.TreeIndex);
+
+        var result = PrioritySplittingUtils.ConvertPrimitiveGroupsToNodes(geometryGroups);
+
+        Assert.That(result, Has.Length.EqualTo(3));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result[treeIndexOneLargeOneSmallPrimitive].Geometries, Has.Length.EqualTo(1));
+            Assert.That(result[treeIndexTwoSmallPrimitives].Geometries, Has.Length.EqualTo(2));
+            Assert.That(result[treeIndexTwoLargePrimitives].Geometries, Has.Length.EqualTo(2));
+        });
+    }
+
+    private static Box CreatePrimitive(float size, uint treeIndex, string? discipline = null)
+    {
+        return new Box(Matrix4x4.Identity, treeIndex, Color.Black, new BoundingBox(Vector3.Zero, size * Vector3.One))
+        {
+            Discipline = discipline
+        };
+    }
+
+    private static CadRevealNode CreateCadRevealNode(uint treeIndex, string discipline, bool hasTagAttribute)
+    {
+        const string dummyName = "dummyName";
+
+        return new CadRevealNode
+        {
+            Attributes = hasTagAttribute
+                ? new Dictionary<string, string> { ["Discipline"] = discipline, ["Tag"] = "tag" }
+                : new Dictionary<string, string> { ["Discipline"] = discipline },
+            Geometries = [CreatePrimitive(1.0f, treeIndex)],
+            TreeIndex = treeIndex,
+            Name = dummyName,
+            Parent = null
+        };
+    }
+}

CadRevealComposer.Tests/SequentialIdGeneratorTests.cs

@@ -0,0 +1,33 @@
+namespace CadRevealComposer.Tests;
+
+using IdProviders;
+
+[TestFixture]
+public class SequentialIdGeneratorTests
+{
+    [TestCase(0u)]
+    [TestCase(10u)]
+    public void GetNodeId_ForFirstId_ReturnsSameAsStartingId(uint firstIdReturned)
+    {
+        // This test tests N random values. It should never fail.
+        var sequentialIdGenerator = new SequentialIdGenerator(firstIdReturned);
+        uint nextId = sequentialIdGenerator.GetNextId();
+        Assert.That(nextId, Is.EqualTo(firstIdReturned));
+        var expectedNextIdFromPeekNextBeforeGetNextId = sequentialIdGenerator.PeekNextId;
+        var nextId2 = sequentialIdGenerator.GetNextId();
+        Assert.That(nextId2, Is.EqualTo(firstIdReturned + 1));
+        Assert.That(nextId2, Is.EqualTo(expectedNextIdFromPeekNextBeforeGetNextId));
+    }
+
+    [Test]
+    public void GetNextId_WhenIdIsAboveFloatMaxInt_ThrowsException()
+    {
+        // This test tests N random values. It should never fail.
+        var sequentialIdGenerator = new SequentialIdGenerator((uint)Math.Pow(2, 24));
+        _ = sequentialIdGenerator.GetNextId(); // Should not throw yet.
+        Assert.That(
+            () => sequentialIdGenerator.GetNextId(),
+            Throws.Exception.With.Message.EqualTo("Too many ids generated")
+        );
+    }
+}

CadRevealComposer.Tests/Utils/HierarchyComposerConverterTests.cs

@@ -56,26 +56,4 @@ public void ConvertToHierarchyNodes_GivenRevealNodes_ConvertsWithoutCrashing()
         );
         Assert.That(firstNode.OptionalDiagnosticInfo, Is.EqualTo(arrangedJson));
     }
-
-    [Test]
-    public void ConvertToHierarchyNodes_GivenRevealNodes_CrashesIfTreeIndexIsOutOfRange()
-    {
-        var node1 = new CadRevealNode()
-        {
-            TreeIndex = uint.MaxValue + 1L,
-            Children = Array.Empty<CadRevealNode>(),
-            BoundingBoxAxisAligned = new BoundingBox(-Vector3.One, Vector3.One),
-            Name = "RootNode",
-            Attributes = { { "RefNo", "=123/321" }, { "Tag", "23L0001" } },
-            Parent = null,
-            Geometries = Array.Empty<APrimitive>()
-        };
-
-        var nodes = new[] { node1 };
-
-        Assert.That(
-            () => HierarchyComposerConverter.ConvertToHierarchyNodes(nodes),
-            Throws.Exception.Message.StartsWith("input was higher than the max uint32 value")
-        );
-    }
 }