Agregar código a la práctica GDI+.

Agreguen una investigación sobre el uso de regiones en GDI+.




private void pictureBox4_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            //Tartas.....????


            /*Un gráfico de tarta es una forma parecida a una tarta; esto es,
             * un arco junto aon las dos líneas que unen sus vértices en el centro
             * de la elipse a la que pertenece el arco.
             * 
             * Para dibujar este tipo de gráficos el objeto Graphics proporciona
             * el método DrawPie que tiene como parámetros los miembros del método
             * DrawArc.**/
            pictureBox4.BackColor = Color.Black;
            Rectangle rect = new Rectangle(10, 10, 200, 100);
            Pen lapiz = new Pen(Color.Green, 3);
            g.DrawPie(lapiz, rect, 30, 150);


            //Polígonos


            /* Un polígono es una forma cerrada definida por tres o más puntos.
             * Por ejemplo un triángulo y un rectángulo son polígonos.
             * 
             * Paradibujar un polígono, son necesarios un objeto Graphics que
             * proporciona el método DrawPolygon, un objeto Pen y una matriz de
             * objetos Point (o PointF).
             * 
             * Esta matriz almacenará los puntos que se van a conectar mediante
             * líneas rectas.
             * 
             * El método DrawPolygon cierra el polígono de forma automática.
             * */


            PointF[] pentagono = {
                                     new Point(20,150),
                                     new Point(130,120),
                                     new Point(230,155),
                                     new Point(190,200),
                                     new Point(45,195)
                                 };


            g.DrawPolygon(lapiz, pentagono);


            //Curvas flexibles


            /* Dos tipos de curvas: cardinales y Bézier.
             * 
             * Cardinal: es una secuencia de curvas individuales combinadas
             * para formar una curva mayor; se especifica mediante una matriz
             * de puntos y un parámetro de tensión que por omisión vale 0.5,
             * y se dibuja invocando a DrawCurve.
             * 
             * Bézier se especifica con cuatro puntos: dos puntos correspondientes
             * a los extremos(p1 y p2) y dos puntos de control (c1 y c2). La curva
             * comienza en p1 y acaba en p2. La curva no pasa por los puntos de 
             * control (c1 y c2), pero estos se comportan como imanes, y tiran de la
             * curva en ciertas direcciones e influyen en el modo en que la curva
             * se dobla. Se dibuja invocando a DrawBeizer.
             * */
            Pen lapizRojo = new Pen(Color.Red);


            Point[] puntos = { 
                             
                                 new Point(25,25),
                                 new Point(50,15),
                                 new Point(100,5),
                                 new Point(120,25),
                                 new Point(150,50),
                                 new Point(220,200),
                                 new Point(120,120),
                             };


            //Dibujar líneas entre los puntos.


            g.DrawLines(lapizRojo, puntos);


            //Dibujar la curva


            g.DrawCurve(Pens.Green, puntos);


            //Puntos que definen la curva flexible de Bézier


            Point p1 = new Point(30, 120);
            Point p2 = new Point(150, 200);
            Point c1 = new Point(75, 10);
            Point c2 = new Point(50, 210);


            //Dibujar la curva


            g.DrawBezier(Pens.GreenYellow, p1, p2, c1, c2);




        }


        private void pictureBox5_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;


            //Trazados


            /* Un trazado es un objeto de la clase GraphicsPath. Se trata de una
             * figura formada por una secuencia de líneas, rectángulos, elipses
             * arcos, polígonos, curvas flexibles, etc., cuyos puntos inicial
             * y final pueden o no ser coincidentes.
             * 
             * Métodos: AddLine, AddRectangle, AddEllipse, AddArc, AddPolygon,
             * AddCurve y AddBeizer.
             * Ejemplo: **/


            GraphicsPath trazado = new GraphicsPath();


            Rectangle rect = new Rectangle(10, 10, 200, 100);
            trazado.AddArc(rect, 45, 135);
            trazado.AddLine(80, 100, 160, 200);
            trazado.CloseFigure();


            g.DrawPath(Pens.Blue, trazado);


        } //fin de PictureBox