Accord.Tests.Vision.NoseHaarCascadeTest.NoseHaarCascadeConstructorTest C# (CSharp) Method

        public void NoseHaarCascadeConstructorTest()
        {
            NoseHaarCascade actual = new NoseHaarCascade();

            HaarCascade expected = HaarCascade.FromXml(new StringReader(Properties.Resources.haarcascade_mcs_nose));

            Assert.AreNotEqual(expected, actual);
            Assert.AreEqual(expected.HasTiltedFeatures, actual.HasTiltedFeatures);
            Assert.AreEqual(expected.Width, actual.Width);
            Assert.AreEqual(expected.Height, actual.Height);
            Assert.AreEqual(expected.Stages.Length, actual.Stages.Length);

            for (int i = 0; i < actual.Stages.Length; i++)
            {
                var aStage = actual.Stages[i];
                var eStage = expected.Stages[i];

                Assert.AreNotEqual(eStage, aStage);

                Assert.AreEqual(aStage.NextIndex, eStage.NextIndex);
                Assert.AreEqual(aStage.ParentIndex, eStage.ParentIndex);
                Assert.AreEqual(aStage.Threshold, eStage.Threshold);

                Assert.AreEqual(aStage.Trees.Length, eStage.Trees.Length);

                for (int j = 0; j < aStage.Trees.Length; j++)
                {
                    var aTree = aStage.Trees[j];
                    var eTree = eStage.Trees[j];

                    Assert.AreNotEqual(eTree, aTree);
                    Assert.AreEqual(eTree.Length, aTree.Length);

                    for (int k = 0; k < aTree.Length; k++)
                    {
                        var aNode = aTree[k];
                        var eNode = eTree[k];

                        Assert.AreNotEqual(eNode, aNode);
                        Assert.AreEqual(eNode.LeftNodeIndex, aNode.LeftNodeIndex);
                        Assert.AreEqual(eNode.LeftValue, aNode.LeftValue, 1e-10);
                        Assert.AreEqual(eNode.RightNodeIndex, aNode.RightNodeIndex, 1e-16);
                        Assert.AreEqual(eNode.RightValue, aNode.RightValue, 1e-16);
                        Assert.AreEqual(eNode.Threshold, aNode.Threshold, 1e-16);
                        Assert.IsFalse(double.IsNaN(aNode.Threshold));

                        Assert.AreEqual(eNode.Feature.Tilted, aNode.Feature.Tilted);
                        Assert.AreEqual(eNode.Feature.Rectangles.Length, aNode.Feature.Rectangles.Length);

                        for (int l = 0; l < eNode.Feature.Rectangles.Length; l++)
                        {
                            var aRect = aNode.Feature.Rectangles[l];
                            var eRect = eNode.Feature.Rectangles[l];

                            Assert.AreNotEqual(eRect, aRect);
                            Assert.AreEqual(eRect.Area, aRect.Area, 1e-16);
                            Assert.AreEqual(eRect.Height, aRect.Height, 1e-16);
                            Assert.AreEqual(eRect.Weight, aRect.Weight, 1e-16);
                            Assert.AreEqual(eRect.Width, aRect.Width, 1e-16);
                            Assert.AreEqual(eRect.X, aRect.X);
                            Assert.AreEqual(eRect.Y, aRect.Y);

                            Assert.IsFalse(double.IsNaN(aRect.Height));
                            Assert.IsFalse(double.IsNaN(aRect.Width));
                            Assert.IsFalse(double.IsNaN(aRect.Area));
                        }
                    }
                }
            }
        }
    }