Пример #1
0
        public void RotateZ_MFacet_MFacetRotatedBy45DegreesAlongZ()
        {
            // arrange
            ShapeEditor editor = new ShapeEditor();

            MFacet testedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            MFacet expectedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            SetPointCoordinatesToDestinationPoint(new MPoint(67.2218246, 21.4228363, 0), expectedFacet.Vertices[0]);
            SetPointCoordinatesToDestinationPoint(new MPoint(111.062447, 48.2928925, 0), expectedFacet.Vertices[1]);
            SetPointCoordinatesToDestinationPoint(new MPoint(54.4939041, 65.26346, 0), expectedFacet.Vertices[2]);

            double angle = 45;


            // act
            editor.RotateZ(testedFacet, angle);


            // assert
            CompareLogic compareLogic = new CompareLogic();

            var comparsionResult = compareLogic.Compare(expectedFacet, testedFacet);

            Assert.IsTrue(comparsionResult.AreEqual);
        }
Пример #2
0
        public List <MPoint> RasterizePolygon(MFacet polygon)
        {
            var points = new List <MPoint>();

            SortVertices(polygon.Vertices);

            var upperRightCorner = GetMaxCoordinates(polygon.Vertices);
            var bottomLeftCorner = GetMinCoordinates(polygon.Vertices);

            for (int i = (int)bottomLeftCorner.X; i <= upperRightCorner.X; ++i)
            {
                for (int j = (int)bottomLeftCorner.Y; j <= upperRightCorner.Y; ++j)
                {
                    bool inside = true;

                    var p = new MPoint(i, j, 1);

                    inside &= EdgeFunction(polygon.Vertices[0], polygon.Vertices[1], p);
                    inside &= EdgeFunction(polygon.Vertices[1], polygon.Vertices[2], p);
                    inside &= EdgeFunction(polygon.Vertices[2], polygon.Vertices[0], p);

                    if (inside)
                    {
                        points.Add(p);
                    }
                }
            }

            return(points);
        }
Пример #3
0
        public void RotateY_MFacet_MFacetRotatedBy45DegreesAlongZ()
        {
            // arrange
            ShapeEditor editor = new ShapeEditor();

            MFacet testedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            MFacet expectedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            SetPointCoordinatesToDestinationPoint(new MPoint(57.32233, 35, 17.67767), expectedFacet.Vertices[0]);
            SetPointCoordinatesToDestinationPoint(new MPoint(92.67767, 23, -17.67767), expectedFacet.Vertices[1]);
            SetPointCoordinatesToDestinationPoint(new MPoint(72.87868, 75, 2.12132025), expectedFacet.Vertices[2]);

            double angle = 45;


            // act
            editor.RotateY(testedFacet, angle);


            // assert
            CompareLogic compareLogic = new CompareLogic();

            var comparsionResult = compareLogic.Compare(expectedFacet, testedFacet);

            Assert.IsTrue(comparsionResult.AreEqual);
        }
Пример #4
0
        public void RotateX_MFacet_MFacetRotatedBy45DegreesAlongZ()
        {
            // arrange
            ShapeEditor editor = new ShapeEditor();

            MFacet testedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            MFacet expectedFacet = new MFacet(new MPoint(50, 35, 0), new MPoint(100, 23, 0), new MPoint(72, 75, 0));

            SetPointCoordinatesToDestinationPoint(new MPoint(50, 39.1005058, -9.899494), expectedFacet.Vertices[0]);
            SetPointCoordinatesToDestinationPoint(new MPoint(100, 30.6152229, -18.3847752), expectedFacet.Vertices[1]);
            SetPointCoordinatesToDestinationPoint(new MPoint(72, 67.38478, 18.3847752), expectedFacet.Vertices[2]);

            double angle = 45;


            // act
            editor.RotateX(testedFacet, angle);


            // assert
            CompareLogic compareLogic = new CompareLogic();

            var comparsionResult = compareLogic.Compare(expectedFacet, testedFacet);

            Assert.IsTrue(comparsionResult.AreEqual);
        }
Пример #5
0
        public void Move_MFacet_MFacetShiftedByMinus10AlongYAndBy208AlongX()
        {
            // arrange
            ShapeEditor editor = new ShapeEditor();

            MFacet testedFacet = new MFacet(new MPoint(26, 18, 20), new MPoint(156, 74, 12), new MPoint(85, 26, 0));

            MFacet expectedFacet = new MFacet(new MPoint(26, 18, 20), new MPoint(156, 74, 12), new MPoint(85, 26, 0));

            SetPointCoordinatesToDestinationPoint(new MPoint(234, 8, 20), expectedFacet.Vertices[0]);
            SetPointCoordinatesToDestinationPoint(new MPoint(364, 64, 12), expectedFacet.Vertices[1]);
            SetPointCoordinatesToDestinationPoint(new MPoint(293, 16, 0), expectedFacet.Vertices[2]);

            float distanceY = -10, distanceX = 208;


            // act
            editor.Translate(testedFacet, distanceX, distanceY, 0);


            // assert
            CompareLogic compareLogic = new CompareLogic();

            var comparsionResult = compareLogic.Compare(expectedFacet, testedFacet);

            Assert.IsTrue(comparsionResult.AreEqual);
        }
Пример #6
0
        public void Move_MFacet_MFacetShiftedBy21AlongZ()
        {
            // arrange
            ShapeEditor editor = new ShapeEditor();

            MFacet testedFacet = new MFacet(new MPoint(12, 10, -3), new MPoint(80, 49, 0), new MPoint(34, 105, 4));

            MFacet expectedFacet = new MFacet(new MPoint(12, 10, -3), new MPoint(80, 49, 0), new MPoint(34, 105, 4));

            SetPointCoordinatesToDestinationPoint(new MPoint(12, 10, 18), expectedFacet.Vertices[0]);
            SetPointCoordinatesToDestinationPoint(new MPoint(80, 49, 21), expectedFacet.Vertices[1]);
            SetPointCoordinatesToDestinationPoint(new MPoint(34, 105, 25), expectedFacet.Vertices[2]);

            float distanceZ = 21;


            // act
            editor.Translate(testedFacet, 0, 0, distanceZ);


            // assert
            CompareLogic compareLogic = new CompareLogic();

            var comparsionResult = compareLogic.Compare(expectedFacet, testedFacet);

            Assert.IsTrue(comparsionResult.AreEqual);
        }
Пример #7
0
        public List <MPoint> triangle(MFacet triangle)
        {
            var points = new List <MPoint>();

            Vector2 vertex0 = new Vector2(triangle.Vertices[0].X, triangle.Vertices[0].Y),
                    vertex1 = new Vector2(triangle.Vertices[1].X, triangle.Vertices[1].Y),
                    vertex2 = new Vector2(triangle.Vertices[2].X, triangle.Vertices[2].Y);

            if (vertex0.Y == vertex1.Y && vertex0.Y == vertex2.Y)
            {
                return(new BresenhamLine().GetLine(triangle.Vertices[0], triangle.Vertices[2]));
            }
            // sort the vertices, vertex0, vertex1, vertex2 lower-to-upper
            if (vertex0.Y > vertex1.Y)
            {
                Swap(ref vertex0, ref vertex1);
            }
            if (vertex0.Y > vertex2.Y)
            {
                Swap(ref vertex0, ref vertex2);
            }
            if (vertex1.Y > vertex2.Y)
            {
                Swap(ref vertex1, ref vertex2);
            }

            int total_height = (int)(vertex2.Y - vertex0.Y);

            for (int i = 0; i < total_height; i++)
            {
                bool second_half = i > vertex1.Y - vertex0.Y || vertex1.Y == vertex0.Y;

                int segment_height = second_half ? (int)(vertex2.Y - vertex1.Y) : (int)(vertex1.Y - vertex0.Y);

                float alpha = (float)i / total_height;
                float beta  = (float)(i - (second_half ? vertex1.Y - vertex0.Y : 0)) / segment_height; // be careful: with above conditions no division by zero here

                Vector2 A = vertex0 + (vertex2 - vertex0) * alpha;
                Vector2 B = second_half ? vertex1 + (vertex2 - vertex1) * beta : vertex0 + (vertex1 - vertex0) * beta;

                if (A.X > B.X)
                {
                    Swap(ref A, ref B);
                }

                for (int j = (int)A.X; j <= B.X; j++)
                {
                    points.Add(new MPoint(j, vertex0.Y + i, 100));

                    if (j > B.X || (A.X < vertex0.X && A.X < vertex1.X && A.X < vertex2.X))
                    {
                        Swap(ref vertex0, ref vertex0);
                    }
                }
            }

            return(points);
        }