Example #1
0
        public static ScalarField <Face> XDependentScalarField(IPolyhedron polyhedron, double average, double deviation)
        {
            var normals = FaceIndexedTableFactory.Normals(polyhedron);
            var values  = polyhedron.Faces.Select(face => average + deviation * normals[polyhedron.IndexOf(face)][0]).ToArray();

            return(new ScalarField <Face>(polyhedron.IndexOf, values));
        }
        public void Areas_OnACube_ShouldCalculateTheCorrectAreas
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var correctArea = 4.0;
            var expected    = Enumerable.Repeat(correctArea, 6).ToList();

            // Exercise system
            var actual = FaceIndexedTableFactory.Areas(polyhedron);

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }
        public void EdgeLengths_OnACube_ShouldCreateSixListsOfFourElements
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var expected = Enumerable.Repeat(4, 6).ToList();

            // Exercise system
            var edgeLengths = FaceIndexedTableFactory.EdgeLengths(polyhedron);

            var actual = edgeLengths.Select(list => list.Count()).ToList();

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual));

            // Teardown
        }
        public void AreasInEachVertex_OnACube_ShouldAllBeCorrect
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var expected = Enumerable.Repeat(1.0, 24).ToList();

            // Exercise system
            var areas = FaceIndexedTableFactory.AreaInEachVertex(polyhedron);

            // Verify outcome
            var actual = areas.SelectMany(listOfAreas => listOfAreas).ToList();

            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }
        public void Neighbours_OnACube_ShouldHaveEachIndexAppearFourTimesTotal
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var expected = Enumerable.Repeat(Enumerable.Range(0, 6), 4).SelectMany(list => list).ToList();

            // Exercise system
            var neighbours = FaceIndexedTableFactory.Neighbours(polyhedron);

            var actual = neighbours.SelectMany(list => list).ToList();

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual));

            // Teardown
        }
        public void EdgeLengths_OnACube_ShouldCalculateTheCorrectLengths
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var correctLength = Math.Sqrt(3) * Trig.InverseCosine(1.0 / 3.0);
            var expected      = Enumerable.Repeat(correctLength, 24).ToList();

            // Exercise system
            var edgeLengths = FaceIndexedTableFactory.EdgeLengths(polyhedron);

            var actual = edgeLengths.SelectMany(list => list).ToList();

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }
        public void Distances_OnACube_ShouldCalculateTheCorrectDistances
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var correctDistance = Math.Sqrt(3) * Math.PI / 2;
            var expected        = Enumerable.Repeat(correctDistance, 24).ToList();

            // Exercise system
            var distances = FaceIndexedTableFactory.Distances(polyhedron);

            var actual = distances.SelectMany(list => list).ToList();

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }
        public void Neighbours_OnACube_ShouldBeCommutative
            (IPolyhedron polyhedron)
        {
            // Fixture setup

            // Exercise system
            var neighbourTable = FaceIndexedTableFactory.Neighbours(polyhedron);

            // Verify outcome
            for (int face = 0; face < neighbourTable.Length; face++)
            {
                foreach (var neighbour in neighbourTable[face])
                {
                    Assert.Contains(face, neighbourTable[neighbour]);
                }
            }

            // Teardown
        }
        public void Vertices_ShouldBeCorrectIndices
            (IPolyhedron polyhedron)
        {
            // Fixture setup

            // Exercise system
            var vertexIndices = FaceIndexedTableFactory.Vertices(polyhedron);

            // Verify outcome
            for (int i = 0; i < polyhedron.Faces.Count; i++)
            {
                var face     = polyhedron.Faces[i];
                var expected = face.Vertices;

                var actual = vertexIndices[i].Select(j => polyhedron.Vertices[j]).ToList();

                TestUtilities.WriteExpectedAndActual(expected, actual);
                Assert.True(Enumerable.SequenceEqual(expected, actual));
            }

            // Teardown
        }
        public void Directions_OfTheTopFaceOfACube_ShouldCalculateTheCorrectDirections
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var expected = new List <Vector>
            {
                VectorUtilities.NewVector(1, 0, 0),
                VectorUtilities.NewVector(-1, 0, 0),
                VectorUtilities.NewVector(0, 1, 0),
                VectorUtilities.NewVector(0, -1, 0)
            };

            // Exercise system
            var topFace = polyhedron.Faces.First(face => face.Vertices.All(vertex => vertex.Position[2] > 0.5));
            var actual  = FaceIndexedTableFactory.Directions(polyhedron)[polyhedron.Faces.IndexOf(topFace)];

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }
        public void Neighbours_OnACube_ShouldListNeighboursInAnticlockwiseOrder
            (IPolyhedron polyhedron)
        {
            // Fixture setup

            // Exercise system
            var neighbourTable = FaceIndexedTableFactory.Neighbours(polyhedron);

            // Verify outcome
            for (int i = 0; i < neighbourTable.Length; i++)
            {
                var centerOfFace = polyhedron.Faces[i].SphericalCenter();
                var viewVector   = -centerOfFace.Normalize();

                var neighbours          = neighbourTable[i].Select(index => polyhedron.Faces[index]);
                var centersOfNeighbours = neighbours.Select(neighbour => neighbour.SphericalCenter()).ToList();

                Assert.True(TestUtilities.AreInAntiClockwiseOrder(centersOfNeighbours, centerOfFace, viewVector));
            }

            // Teardown
        }
        public void Normals_OnACube_ShouldCalculateTheCorrectNormals
            (IPolyhedron polyhedron)
        {
            // Fixture setup
            var expected = new List <Vector>
            {
                VectorUtilities.NewVector(1, 0, 0),
                VectorUtilities.NewVector(-1, 0, 0),
                VectorUtilities.NewVector(0, 1, 0),
                VectorUtilities.NewVector(0, -1, 0),
                VectorUtilities.NewVector(0, 0, 1),
                VectorUtilities.NewVector(0, 0, -1)
            };

            // Exercise system
            var actual = FaceIndexedTableFactory.Normals(polyhedron);

            // Verify outcome
            TestUtilities.WriteExpectedAndActual(expected, actual);
            Assert.True(TestUtilities.UnorderedEquals(expected, actual, TestUtilities.RelativeAccuracy));

            // Teardown
        }