WIP: Feature/coarse and nodes combined

CadRevealComposer.Exe/CommandLineOptions.cs

@@ -78,6 +78,20 @@ public class CommandLineOptions
     )]
     public string? NodeNameExcludeRegex { get; init; } = null;
 
+    [Option(
+        longName: "PrioritizedDiscipline",
+        Required = false,
+        HelpText = "A regex matching disciplines to be prioritized in sector splitting. Not case sensitive."
+    )]
+    public string? PrioritizedDisciplineRegex { get; init; } = null;
+
+    [Option(
+        longName: "PrioritizedNodeName",
+        Required = false,
+        HelpText = "A regex matching node names to be prioritized in sector splitting. Not case sensitive."
+    )]
+    public string? PrioritizedNodeNameRegex { get; init; } = null;
+
     [Option(longName: "SplitIntoZones", shortName: 'z', Required = false, HelpText = "Split models into zones.")]
     public bool SplitIntoZones { get; init; }
 

CadRevealComposer.Exe/Program.cs

@@ -58,11 +58,31 @@ private static int RunOptionsAndReturnExitCode(CommandLineOptions options)
                 );
         }
 
+        if (options.PrioritizedDisciplineRegex != null)
+        { // Ensure regex is valid.
+            if (!RegexUtils.IsValidRegex(options.PrioritizedDisciplineRegex))
+                throw new ArgumentException(
+                    $"The {nameof(options.PrioritizedDisciplineRegex)} is not a valid regex. Check its syntax. "
+                        + $"The input was: {options.PrioritizedDisciplineRegex}"
+                );
+        }
+
+        if (options.PrioritizedNodeNameRegex != null)
+        { // Ensure regex is valid.
+            if (!RegexUtils.IsValidRegex(options.PrioritizedNodeNameRegex))
+                throw new ArgumentException(
+                    $"The {nameof(options.PrioritizedNodeNameRegex)} is not a valid regex. Check its syntax. "
+                        + $"The input was: {options.PrioritizedNodeNameRegex}"
+                );
+        }
+
         var toolsParameters = new ComposerParameters(
             options.NoInstancing,
             options.SingleSector,
             options.SplitIntoZones,
-            new NodeNameExcludeRegex(options.NodeNameExcludeRegex)
+            new NodeNameExcludeRegex(options.NodeNameExcludeRegex),
+            new PrioritizedDisciplinesRegex(options.PrioritizedDisciplineRegex),
+            new PrioritizedNodeNamesRegex(options.PrioritizedNodeNameRegex)
         );
 
         if (options.SplitIntoZones)

CadRevealComposer.Tests/Operations/DrawCallEstimatorTests.cs

@@ -28,6 +28,7 @@ public void ConeAndCylinder()
         var geometry = new APrimitive[]
         {
             new Cone(
+                Matrix4x4.Identity,
                 0f,
                 0f,
                 Vector3.One,
@@ -40,6 +41,7 @@ public void ConeAndCylinder()
                 new BoundingBox(-Vector3.One, Vector3.One)
             ),
             new GeneralCylinder(
+                Matrix4x4.Identity,
                 0f,
                 0f,
                 Vector3.One,
@@ -64,6 +66,7 @@ public void SolidClosedGeneralConeTorusAndClosedCylinder()
         var geometry = new APrimitive[]
         {
             new Cone(
+                Matrix4x4.Identity,
                 0f,
                 0f,
                 Vector3.One,
@@ -85,6 +88,7 @@ public void SolidClosedGeneralConeTorusAndClosedCylinder()
                 new BoundingBox(-Vector3.One, Vector3.One)
             ),
             new GeneralCylinder(
+                Matrix4x4.Identity,
                 0f,
                 0f,
                 Vector3.One,

CadRevealComposer.Tests/Shadow/ConeShadowCreatorTests.cs

@@ -0,0 +1,65 @@
+namespace CadRevealComposer.Tests.Shadow;
+
+using CadRevealComposer.Primitives;
+using CadRevealComposer.Shadow;
+using CadRevealComposer.Utils;
+using System;
+using System.Drawing;
+using System.Numerics;
+
+[TestFixture]
+public class ConeShadowCreatorTests
+{
+    [Test]
+    public void ConvertToBox()
+    {
+        var matrix = Matrix4x4.Identity;
+
+        var centerA = new Vector3(0, 0, 0);
+        var centerB = new Vector3(0, 0, 2);
+
+        var min = new Vector3(-1, -1, 0);
+        var max = new Vector3(1, 1, 2);
+        var bb = new BoundingBox(min, max);
+
+        var radiusA = 1f;
+        var radiusB = 2f;
+        var height = Vector3.Distance(centerA, centerB);
+
+        var cone = new Cone(
+            matrix,
+            0f,
+            2 * MathF.PI,
+            centerA,
+            centerB,
+            Vector3.UnitX,
+            radiusA,
+            radiusB,
+            0,
+            Color.Red,
+            bb
+        );
+
+        var result = cone.CreateShadow();
+
+        Assert.IsTrue(result is Box);
+
+        Assert.AreEqual(cone.TreeIndex, result.TreeIndex);
+        Assert.AreEqual(cone.Color, result.Color);
+        Assert.AreEqual(cone.AxisAlignedBoundingBox, result.AxisAlignedBoundingBox);
+
+        var box = (Box)result;
+
+        if (!box.InstanceMatrix.DecomposeAndNormalize(out var scale, out var rotation, out var position))
+        {
+            throw new Exception("Failed to decompose matrix to transform. Input Matrix: " + box.InstanceMatrix);
+        }
+
+        var largestRadius = MathF.Max(radiusA, radiusB);
+        var expectedScale = new Vector3(largestRadius * 2, largestRadius * 2, height);
+
+        Assert.AreEqual(expectedScale, scale);
+        Assert.AreEqual(Quaternion.Identity, rotation);
+        Assert.AreEqual(Vector3.Zero, position);
+    }
+}

CadRevealComposer.Tests/Shadow/CylinderShadowCreatorTests.cs

@@ -0,0 +1,65 @@
+namespace CadRevealComposer.Tests.Shadow;
+
+using CadRevealComposer.Primitives;
+using CadRevealComposer.Shadow;
+using CadRevealComposer.Utils;
+using NUnit.Framework;
+using System;
+using System.Drawing;
+using System.Numerics;
+
+[TestFixture]
+public class CylinderShadowCreatorTests
+{
+    [Test]
+    public void ConvertToBox()
+    {
+        var matrix = Matrix4x4.Identity;
+
+        var centerA = new Vector3(0, 0, 0);
+        var centerB = new Vector3(0, 0, 2);
+
+        var min = new Vector3(-1, -1, 0);
+        var max = new Vector3(1, 1, 2);
+        var bb = new BoundingBox(min, max);
+
+        var radius = 2f;
+        var height = Vector3.Distance(centerA, centerB);
+
+        var cylinder = new GeneralCylinder(
+            matrix,
+            0f,
+            2 * MathF.PI,
+            centerA,
+            centerB,
+            Vector3.UnitX,
+            Vector4.UnitZ,
+            Vector4.UnitZ,
+            radius,
+            0,
+            Color.Red,
+            bb
+        );
+
+        var result = cylinder.CreateShadow();
+
+        Assert.IsTrue(result is Box);
+
+        Assert.AreEqual(cylinder.TreeIndex, result.TreeIndex);
+        Assert.AreEqual(cylinder.Color, result.Color);
+        Assert.AreEqual(cylinder.AxisAlignedBoundingBox, result.AxisAlignedBoundingBox);
+
+        var box = (Box)result;
+
+        if (!box.InstanceMatrix.DecomposeAndNormalize(out var scale, out var rotation, out var position))
+        {
+            throw new Exception("Failed to decompose matrix to transform. Input Matrix: " + box.InstanceMatrix);
+        }
+
+        var expectedScale = new Vector3(radius * 2, radius * 2, height);
+
+        Assert.AreEqual(expectedScale, scale);
+        Assert.AreEqual(Quaternion.Identity, rotation);
+        Assert.AreEqual(Vector3.Zero, position);
+    }
+}

CadRevealComposer.Tests/Shadow/EccentricConeShadowCreatorTests.cs

@@ -0,0 +1,63 @@
+namespace CadRevealComposer.Tests.Shadow;
+
+using CadRevealComposer.Primitives;
+using CadRevealComposer.Shadow;
+using CadRevealComposer.Utils;
+using System;
+using System.Drawing;
+using System.Numerics;
+
+[TestFixture]
+public class EccentricConeShadowCreatorTests
+{
+    [Test]
+    public void ConvertToBox()
+    {
+        var matrix = Matrix4x4.Identity;
+
+        var centerA = new Vector3(0, 0, 0);
+        var centerB = new Vector3(0, 0, 2);
+
+        var min = new Vector3(-1, -1, 0);
+        var max = new Vector3(1, 1, 2);
+        var bb = new BoundingBox(min, max);
+
+        var radiusA = 2f;
+        var radiusB = 3f;
+        var height = Vector3.Distance(centerA, centerB);
+
+        var eccentricCone = new EccentricCone(
+            matrix,
+            centerA,
+            centerB,
+            Vector3.UnitX,
+            radiusA,
+            radiusB,
+            0,
+            Color.Red,
+            bb
+        );
+
+        var result = eccentricCone.CreateShadow();
+
+        Assert.IsTrue(result is Box);
+
+        Assert.AreEqual(eccentricCone.TreeIndex, result.TreeIndex);
+        Assert.AreEqual(eccentricCone.Color, result.Color);
+        Assert.AreEqual(eccentricCone.AxisAlignedBoundingBox, result.AxisAlignedBoundingBox);
+
+        var box = (Box)result;
+
+        if (!box.InstanceMatrix.DecomposeAndNormalize(out var scale, out var rotation, out var position))
+        {
+            throw new Exception("Failed to decompose matrix to transform. Input Matrix: " + box.InstanceMatrix);
+        }
+
+        var largestRadius = MathF.Max(radiusA, radiusB);
+        var expectedScale = new Vector3(largestRadius * 2, largestRadius * 2, height);
+
+        Assert.AreEqual(expectedScale, scale);
+        Assert.AreEqual(Quaternion.Identity, rotation);
+        Assert.AreEqual(Vector3.Zero, position);
+    }
+}

CadRevealComposer.Tests/Shadow/EllipsoidSegmentShadowCreatorTests.cs

@@ -0,0 +1,65 @@
+namespace CadRevealComposer.Tests.Shadow;
+
+using CadRevealComposer.Primitives;
+using CadRevealComposer.Shadow;
+using CadRevealComposer.Utils;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+[TestFixture]
+public class EllipsoidSegmentShadowCreatorTests
+{
+    [Test]
+    public void ConvertToBox()
+    {
+        var matrix = Matrix4x4.Identity;
+
+        var center = new Vector3(0, 0, 0);
+
+        var min = new Vector3(-1, -1, 0);
+        var max = new Vector3(1, 1, 2);
+        var bb = new BoundingBox(min, max);
+
+        var horizontalRadius = 2f;
+        var verticalRadius = 3f;
+        var height = 4f;
+
+        var ellipsoidSegment = new EllipsoidSegment(
+            matrix,
+            horizontalRadius,
+            verticalRadius,
+            height,
+            center,
+            Vector3.UnitX,
+            0,
+            Color.Red,
+            bb
+        );
+
+        var result = ellipsoidSegment.CreateShadow();
+
+        Assert.IsTrue(result is Box);
+
+        Assert.AreEqual(ellipsoidSegment.TreeIndex, result.TreeIndex);
+        Assert.AreEqual(ellipsoidSegment.Color, result.Color);
+        Assert.AreEqual(ellipsoidSegment.AxisAlignedBoundingBox, result.AxisAlignedBoundingBox);
+
+        var box = (Box)result;
+
+        if (!box.InstanceMatrix.DecomposeAndNormalize(out var scale, out var rotation, out var position))
+        {
+            throw new Exception("Failed to decompose matrix to transform. Input Matrix: " + box.InstanceMatrix);
+        }
+
+        var expectedScale = new Vector3(horizontalRadius * 2, horizontalRadius * 2, height);
+
+        Assert.AreEqual(expectedScale, scale);
+        Assert.AreEqual(Quaternion.Identity, rotation);
+        Assert.AreEqual(Vector3.Zero, position);
+    }
+}