Class Graphics

Class Graphics

Nombre del espacio: Aspose.Imaging Asamblea: Aspose.Imaging.dll (25.4.0)

Representa los gráficos según el motor gráfico utilizado en la configuración actual.

public sealed class Graphics

Inheritance

object Graphics

Miembros heredados

object.GetType() ,y, object.ToString() ,y, object.Equals(object?) ,y, object.Equals(object?, object?) ,y, object.ReferenceEquals(object?, object?) ,y, object.GetHashCode()

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Constructors

Graphics(Image)

Inicia una nueva instancia de la clase Aspose.Imaging.Graphics.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

La imagen de la fuente.

Properties

Clip

Obtenga o coloca la región de clip.

public Region Clip { get; set; }

Valor de la propiedad

Region

CompositingQuality

Obtenga o establece la calidad de la composición.

public CompositingQuality CompositingQuality { get; set; }

Valor de la propiedad

CompositingQuality

Dpix

Obtenga la resolución horizontal de este Aspose.Imaging.Graphics.

public float DpiX { get; }

Valor de la propiedad

float

Dpiya

Obtenga la resolución vertical de este Aspose.Imaging.Graphics.

public float DpiY { get; }

Valor de la propiedad

float

Image

Obtenga la imagen.

public Image Image { get; }

Valor de la propiedad

Image

InterpolationMode

Obtenga o establece el modo de interpolación.

public InterpolationMode InterpolationMode { get; set; }

Valor de la propiedad

InterpolationMode

IsInBeginUpdateCall

Obtenga un valor que indica si el gráfico está en el estado de llamado BeginUpdate.

public bool IsInBeginUpdateCall { get; }

Valor de la propiedad

bool

PageScale

Obtenga o establece la escala entre las unidades del mundo y las unidades de página para este Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Valor de la propiedad

float

PageUnit

Obtenga o establece la unidad de medida utilizada para las coordenadas de la página en este Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Valor de la propiedad

GraphicsUnit

PaintableImageOptions

Obtenga o establece opciones de imagen, utilizadas para crear imágenes de vacío pintables para dibujar.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valor de la propiedad

ImageOptionsBase

SmoothingMode

Obtenga o establece el modo de deslizamiento.

public SmoothingMode SmoothingMode { get; set; }

Valor de la propiedad

SmoothingMode

TextRenderingHint

Obtenga o establece el texto de orientación.

public TextRenderingHint TextRenderingHint { get; set; }

Valor de la propiedad

TextRenderingHint

Transform

Obtenga o coloca una copia de la transformación del mundo geométrico para este Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Valor de la propiedad

Matrix

Methods

BeginUpdate()

Los efectos gráficos aplicados posteriormente no se aplicarán de inmediato en lugar de que el EndUpdate causará la aplicación de todos los efectos a la vez.

public void BeginUpdate()

Remarks

Tenga en cuenta que los efectos después de que se llame StartUpdate no se aplicará en caso de que no se llame StartUpdate.

Clear(Color)

Limpiar la superficie gráfica utilizando el color especificado.

public void Clear(Color color)

Parameters

color Color

El color para limpiar la superficie gráfica por.

Examples

Estos ejemplos hacen uso de la clase GraphicsPath y Graphics para crear y manipular Figuras en una superficie de imagen. El ejemplo crea una nueva imagen (de tipo Tiff), limpia la superficie y atrae caminos con la ayuda de la clase GraphicsPath. Al final, el método DrawPath expuesto por la clase Graphics se llama a rendir los caminos en la superficie.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                     //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                     //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                     graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                     // save all changes.
                                                                                                                                                                                                                                                                                                                                                     image.Save();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

DrawArc(Pino, float, float, float, float, float)

Un arco representa una porción de un ellipse especificado por un par de coordenadas, una anchura y una altura.

public void DrawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del arco.

x float

El coordenado x del ángulo superior izquierdo del rectángulo que define la elipse.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo que define la elipse.

width float

La amplitud del rectángulo que define el elípsis.

height float

La altura del rectángulo que define la elipse.

startAngle float

El ángulo en grados se mide en forma de reloj desde el eixo x hasta el punto de partida del arco.

sweepAngle float

ngulo en grados medido a partir del parámetro startAngle’ para terminar el punto del arco.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Un arco representa una porción de un ellipse especificado por una estructura Aspose.Imaging.RectangleF.

public void DrawArc(Pen pen, RectangleF rect, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del arco.

rect RectangleF

Aspose.Imaging.RectangleF estructura que define los límites de la elípsis.

startAngle float

El ángulo en grados se mide en forma de reloj desde el eixo x hasta el punto de partida del arco.

sweepAngle float

ngulo en grados medido a partir del parámetro startAngle’ para terminar el punto del arco.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pén, int, int, int, int, int)

Un arco representa una porción de un ellipse especificado por un par de coordenadas, una anchura y una altura.

public void DrawArc(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del arco.

x int

El coordenado x del ángulo superior izquierdo del rectángulo que define la elipse.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo que define la elipse.

width int

La amplitud del rectángulo que define el elípsis.

height int

La altura del rectángulo que define la elipse.

startAngle int

El ángulo en grados se mide en forma de reloj desde el eixo x hasta el punto de partida del arco.

sweepAngle int

ngulo en grados medido a partir del parámetro startAngle’ para terminar el punto del arco.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, rectangle, float, float)

Un arco representa una porción de una ellipse especificada por una estructura de Aspose.Imaging.Rectangle.

public void DrawArc(Pen pen, Rectangle rect, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del arco.

rect Rectangle

Aspose.Imaging.RectangleF estructura que define los límites de la elípsis.

startAngle float

El ángulo en grados se mide en forma de reloj desde el eixo x hasta el punto de partida del arco.

sweepAngle float

ngulo en grados medido a partir del parámetro startAngle’ para terminar el punto del arco.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(La flota, la flota, la flota, la flota, la flota, la flota, la flota)

Es una línea Bézier definida por cuatro pares ordenados de coordenadas que representan puntos.

public void DrawBezier(Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la curva.

x1 float

La coordenada x del punto de partida de la curva.

y1 float

El y-coordenado del punto de partida de la curva.

x2 float

La coordenada x del primer punto de control de la curva.

y2 float

El y-coordenado del primer punto de control de la curva.

x3 float

La coordenada x del segundo punto de control de la curva.

y3 float

El y-coordenado del segundo punto de control de la curva.

x4 float

La coordenada x del punto final de la curva.

y4 float

El y-coordenado del punto final de la curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Título: PointF, PointF, PointF)

Toma una línea Bézier definida por cuatro estructuras Aspose.Imaging.PointF.

public void DrawBezier(Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la curva.

pt1 PointF

Aspose.Imaging.PointF estructura que representa el punto de partida de la curva.

pt2 PointF

Aspose.Imaging.PointF estructura que representa el primer punto de control para la curva.

pt3 PointF

Aspose.Imaging.PointF estructura que representa el segundo punto de control para la curva.

pt4 PointF

Aspose.Imaging.PointF estructura que representa el punto final de la curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Punto, punto, punto y punto)

Toma una línea Bézier definida por cuatro estructuras Aspose.Imaging.Point.

public void DrawBezier(Pen pen, Point pt1, Point pt2, Point pt3, Point pt4)

Parameters

pen Pen

Aspose.Imaging.Pen estructura que determina el color, ancho y estilo de la curva.

pt1 Point

Aspose.Imaging.Point estructura que representa el punto de partida de la curva.

pt2 Point

Aspose.Imaging.Point estructura que representa el primer punto de control para la curva.

pt3 Point

Aspose.Imaging.Point estructura que representa el segundo punto de control para la curva.

pt4 Point

Aspose.Imaging.Point estructura que representa el punto final de la curva.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawBeziers(El punto, el punto[])

Entra una serie de pistas de Bézier de una serie de estructuras de Aspose.Imaging.Point.

public void DrawBeziers(Pen pen, Point[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que representan los puntos que determinan la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawBeziers(Pintura, PointF[])

Entra una serie de pistas de Bézier de una serie de estructuras de Aspose.Imaging.PointF.

public void DrawBeziers(Pen pen, PointF[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la curva.

points PointF [][]

Array de Aspose.Imaging.PointF estructuras que representan los puntos que determinan la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawClosedCurve(Pintura, PointF[])

Tiene una línea cardinal cerrada definida por una serie de estructuras de Aspose.Imaging.PointF. Este método utiliza una tensión predeterminada de 0.5 y el modo de relleno de Aspose.Imaging.FillMode.Alternate.

public void DrawClosedCurve(Pen pen, PointF[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawClosedCurve(Pintura, PointF[][], La flota)

Escribe una línea cardinal cerrada definida por una serie de estructuras Aspose.Imaging.PointF utilizando una tensión especificada.Este método utiliza un modo de relleno default Aspose.Imaging.FillMode.Alternate.

public void DrawClosedCurve(Pen pen, PointF[] points, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawClosedCurve(El punto, el punto[])

Tiene una línea cardinal cerrada definida por una serie de estructuras de Aspose.Imaging.Point. Este método utiliza una tensión predeterminada de 0.5 y el modo de relleno de Aspose.Imaging.FillMode.Alternate.

public void DrawClosedCurve(Pen pen, Point[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawClosedCurve(El punto, el punto[][], La flota)

Escribe una línea cardinal cerrada definida por una serie de estructuras de Aspose.Imaging.Point utilizando una tensión especificada.Este método utiliza un modo de relleno default de Aspose.Imaging.FillMode.Alternate.

public void DrawClosedCurve(Pen pen, Point[] points, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(Pintura, PointF[])

Tira una línea cardinal a través de una serie especificada de estructuras Aspose.Imaging.PointF. Este método utiliza una tensión predeterminada de 0.5.

public void DrawCurve(Pen pen, PointF[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(Pintura, PointF[][], La flota)

Tira una espina cardinal a través de una serie especificada de estructuras Aspose.Imaging.PointF utilizando una tensión especificada.

public void DrawCurve(Pen pen, PointF[] points, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de Aspose.Imaging.PointF estructuras que representan los puntos que definen la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(Pintura, PointF[][], El int, el int)

Entra una espina cardinal a través de una serie especificada de estructuras de Aspose.Imaging.PointF. El dibujo comienza a desembolsar desde el comienzo de la serie.Este método utiliza una tensión estándar de 0.5.

public void DrawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

offset int

Desactivar desde el primer elemento en la línea del parámetro de los puntos hasta el punto de partida en la curva.

numberOfSegments int

Número de segmentos después del punto de partida a incluir en la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(Pintura, PointF[][], int , int , float)

Entra una línea cardinal a través de una serie especificada de estructuras de Aspose.Imaging.PointF utilizando una tensión especificada.

public void DrawCurve(Pen pen, PointF[] points, int offset, int numberOfSegments, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

offset int

Desactivar desde el primer elemento en la línea del parámetro de los puntos hasta el punto de partida en la curva.

numberOfSegments int

Número de segmentos después del punto de partida a incluir en la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(El punto, el punto[])

Entra una espina cardinal a través de una serie especificada de estructuras Aspose.Imaging.Point.

public void DrawCurve(Pen pen, Point[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(El punto, el punto[][], La flota)

Tira una espina cardinal a través de una serie especificada de estructuras Aspose.Imaging.Point utilizando una tensión especificada.

public void DrawCurve(Pen pen, Point[] points, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawCurve(El punto, el punto[][], int , int , float)

Tira una espina cardinal a través de una serie especificada de estructuras Aspose.Imaging.Point utilizando una tensión especificada.

public void DrawCurve(Pen pen, Point[] points, int offset, int numberOfSegments, float tension)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y la altura de la curva.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

offset int

Desactivar desde el primer elemento en la línea del parámetro de los puntos hasta el punto de partida en la curva.

numberOfSegments int

Número de segmentos después del punto de partida a incluir en la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawEllipse(Pén, RectangleF)

Es un ellipse definido por un límite Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la ellipse.

rect RectangleF

Aspose.Imaging.RectangleF estructura que define los límites de la elípsis.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pino, float, float, float, float)

Es un ellipse definido por un rectángulo limitante especificado por un par de coordenadas, una altura y una anchura.

public void DrawEllipse(Pen pen, float x, float y, float width, float height)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la ellipse.

x float

El coordenado x del ángulo superior izquierdo del rectángulo que define el elípsis.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo que define el elípsis.

width float

La anchura del rectángulo que define el elípsis.

height float

La altura del rectángulo fronterizo que define la elipse.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, rectangulo)

Tiene un ellipse especificado por una estructura de Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la ellipse.

rect Rectangle

Aspose.Imaging.Rectangle estructura que define los límites de la elípsis.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pén, int, int, int, int)

Es un ellipse definido por un rectángulo limitante especificado por un par de coordenadas, una altura y una anchura.

public void DrawEllipse(Pen pen, int x, int y, int width, int height)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la ellipse.

x int

El coordenado x del ángulo superior izquierdo del rectángulo que define el elípsis.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo que define el elípsis.

width int

La anchura del rectángulo que define el elípsis.

height int

La altura del rectángulo fronterizo que define la elipse.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Imágenes, PointF)

Retrata el Aspose.Imaging.Graphics.Image especificado, utilizando su tamaño físico original, en la ubicación especificada.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

La imagen con la que dibujar.

point PointF

Aspose.Imaging.PointF estructura que representa el ángulo superior izquierdo de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, float y float)

Retrata el Aspose.Imaging.Graphics.Image especificado, utilizando su tamaño físico original, en la ubicación especificada.

public void DrawImage(Image sourceImage, float x, float y)

Parameters

sourceImage Image

La imagen con la que dibujar.

x float

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y float

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imágenes, RectangleF)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

La imagen con la que dibujar.

rect RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicación y el tamaño de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, Rectangle, GraphicsUnit)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, Rectangle rectDestination, GraphicsUnit graphicsUnit)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectDestination Rectangle

El rectángulo de destino.

graphicsUnit GraphicsUnit

La unidad gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, RectangleF, GraphicsUnit)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, RectangleF rectDestination, GraphicsUnit graphicsUnit)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectDestination RectangleF

El rectángulo de destino.

graphicsUnit GraphicsUnit

La unidad gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, Rectangle, GraphicsUnit, Atributos de imagen)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, Rectangle rectDestination, GraphicsUnit graphicsUnit, ImageAttributes imageAttributes)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectDestination Rectangle

El rectángulo de destino.

graphicsUnit GraphicsUnit

La unidad gráfica.

imageAttributes ImageAttributes

La imagen tiene atributos.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, RectangleF, GraphicsUnit, Atributos de imagen)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, RectangleF rectDestination, GraphicsUnit graphicsUnit, ImageAttributes imageAttributes)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectDestination RectangleF

El rectángulo de destino para atraer.

graphicsUnit GraphicsUnit

La unidad gráfica.

imageAttributes ImageAttributes

La imagen tiene atributos.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, Rectangle, Rectangle, GraphicsUnit)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, Rectangle rectSource, Rectangle rectDestination, GraphicsUnit graphicsUnit)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectSource Rectangle

La fuente rectal.

rectDestination Rectangle

El destino de la derecha.

graphicsUnit GraphicsUnit

La unidad gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, RectangleF, RectangleF, gráficosUnit)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, RectangleF rectSource, RectangleF rectDestination, GraphicsUnit graphicsUnit)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectSource RectangleF

La fuente rectal.

rectDestination RectangleF

El destino de la derecha.

graphicsUnit GraphicsUnit

La unidad gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, Rectangle, Rectangle, GraphicsUnit, Atributos de imagen)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, Rectangle rectSource, Rectangle rectDestination, GraphicsUnit graphicsUnit, ImageAttributes imageAttributes)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectSource Rectangle

La fuente rectal.

rectDestination Rectangle

El destino de la derecha.

graphicsUnit GraphicsUnit

La unidad gráfica.

imageAttributes ImageAttributes

La imagen tiene atributos.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, RectangleF, RectangleF, GraphicsUnit, Atributos de imagen)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, RectangleF rectSource, RectangleF rectDestination, GraphicsUnit graphicsUnit, ImageAttributes imageAttributes)

Parameters

sourceImage Image

La imagen con la que dibujar.

rectSource RectangleF

El rectángulo de la fuente.

rectDestination RectangleF

El rectángulo de destino.

graphicsUnit GraphicsUnit

La unidad gráfica para utilizar.

imageAttributes ImageAttributes

La imagen se atribuye al uso.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(La imagen, punto[])

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, Point[] destPoints)

Parameters

image Image

La imagen para dibujar.

destPoints Point [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

DrawImage(La imagen, punto[][], El rectángulo)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, Point[] destPoints, Rectangle srcRect)

Parameters

image Image

La imagen para dibujar.

destPoints Point [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect Rectangle

El rectángulo de la fuente.

DrawImage(La imagen, punto[][], Rectangle, GraphicsUnit)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, Point[] destPoints, Rectangle srcRect, GraphicsUnit srcUnit)

Parameters

image Image

La imagen para dibujar.

destPoints Point [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect Rectangle

El rectángulo de la fuente.

srcUnit GraphicsUnit

las unidades de medida.

DrawImage(La imagen, punto[][], Rectangle, GraphicsUnit, Atributos de imagen)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, Point[] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttributes)

Parameters

image Image

La imagen para dibujar.

destPoints Point [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect Rectangle

El rectángulo de la fuente.

srcUnit GraphicsUnit

las unidades de medida.

imageAttributes ImageAttributes

La imagen tiene atributos.

DrawImage(Imágenes, PointF[])

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, PointF[] destPoints)

Parameters

image Image

La imagen para dibujar.

destPoints PointF [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

Exceptions

ArgumentNullException

Imagen

DrawImage(Imágenes, PointF[][], de RectangleF)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, PointF[] destPoints, RectangleF srcRect)

Parameters

image Image

La imagen para dibujar.

destPoints PointF [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect RectangleF

El rectángulo de la fuente.

DrawImage(Imágenes, PointF[][], RectangleF, GraphicsUnit)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, PointF[] destPoints, RectangleF srcRect, GraphicsUnit srcUnit)

Parameters

image Image

La imagen para dibujar.

destPoints PointF [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect RectangleF

El rectángulo de la fuente.

srcUnit GraphicsUnit

las unidades de medida.

DrawImage(Imágenes, PointF[][], RectangleF, GraphicsUnit, Atributos de imagen)

Entra la parte especificada de la imagen " en la ubicación especificada y con el tamaño especificado.

public void DrawImage(Image image, PointF[] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttributes)

Parameters

image Image

La imagen para dibujar.

destPoints PointF [][]

Un conjunto de tres estructuras PointF que definen un paralelograma.

srcRect RectangleF

El rectángulo de la fuente.

srcUnit GraphicsUnit

las unidades de medida.

imageAttributes ImageAttributes

La imagen tiene atributos.

DrawImage(Imagen, float, float, float, float)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, float x, float y, float width, float height)

Parameters

sourceImage Image

La imagen con la que dibujar.

x float

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y float

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

width float

Ampliación de la imagen grabada.

height float

La altura de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(La imagen, punto)

Retrata el Aspose.Imaging.Graphics.Image especificado, utilizando su tamaño físico original, en la ubicación especificada.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

La imagen con la que dibujar.

point Point

Aspose.Imaging.Point estructura que representa la ubicación del ángulo superior izquierdo de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(La imagen, int, int)

Tira la imagen especificada, utilizando su tamaño físico original, en la ubicación especificada por un par de coordenadas.

public void DrawImage(Image sourceImage, int x, int y)

Parameters

sourceImage Image

La imagen con la que dibujar.

x int

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y int

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imágenes, Rectangle)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

La imagen con la que dibujar.

rect Rectangle

Aspose.Imaging.Rectangle estructura que especifica la ubicación y el tamaño de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagen, int, int, int, int)

Trague la imagen especificada Aspose.Imaging.Graphics.Image en el lugar especificado y con el tamaño especificado.

public void DrawImage(Image sourceImage, int x, int y, int width, int height)

Parameters

sourceImage Image

La imagen con la que dibujar.

x int

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y int

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

width int

Ampliación de la imagen grabada.

height int

La altura de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(La imagen, punto)

Graba una imagen especificada utilizando su tamaño físico original en un lugar especificado.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

La imagen con la que dibujar.

point Point

Aspose.Imaging.Point estructura que especifica el ángulo superior izquierdo de la imagen grabada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(La imagen, int, int)

Retrata la imagen especificada utilizando su tamaño físico original en la ubicación especificada por un par de coordenadas.

public void DrawImageUnscaled(Image sourceImage, int x, int y)

Parameters

sourceImage Image

La imagen con la que dibujar.

x int

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y int

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imágenes, Rectangle)

Graba una imagen especificada utilizando su tamaño físico original en un lugar especificado.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

La imagen con la que dibujar.

rect Rectangle

Aspose.Imaging.Rectangle que especifica el ángulo superior izquierdo de la imagen grabada.Las propiedades X y Y del ángulo rectangle especifican el ángulo superior izquierdo.Las propiedades de ancho y altura se ignoran.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagen, int, int, int, int)

Graba una imagen especificada utilizando su tamaño físico original en un lugar especificado.

public void DrawImageUnscaled(Image sourceImage, int x, int y, int width, int height)

Parameters

sourceImage Image

La imagen con la que dibujar.

x int

El coordenado x del ángulo superior izquierdo de la imagen grabada.

y int

El y-coordenado del ángulo superior izquierdo de la imagen dibujada.

width int

El parámetro no se utiliza.

height int

El parámetro no se utiliza.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Imágenes, Rectangle)

Retira la imagen especificada sin escalar y la clipa, si es necesario, para encajar en el rectángulo especificado.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

La imagen con la que dibujar.

rect Rectangle

El Aspose.Imaging.Rectangle en el que dibujar la imagen.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(El punto, el punto, el punto)

Escribe una línea que conecta dos estructuras Aspose.Imaging.Point.

public void DrawLine(Pen pen, Point point1, Point point2)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la línea.

point1 Point

Aspose.Imaging.Point estructura que representa el primer punto para conectarse.

point2 Point

Aspose.Imaging.Point estructura que representa el segundo punto para conectarse.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(El punto, el punto, el punto)

Escribe una línea que conecta dos estructuras Aspose.Imaging.PointF.

public void DrawLine(Pen pen, PointF point1, PointF point2)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la línea.

point1 PointF

Aspose.Imaging.PointF estructura que representa el primer punto para conectarse.

point2 PointF

Aspose.Imaging.PointF estructura que representa el segundo punto para conectarse.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pén, int, int, int, int)

Tira una línea que conecta los dos puntos especificados por los pares de coordenadas.

public void DrawLine(Pen pen, int x1, int y1, int x2, int y2)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la línea.

x1 int

El coordenado x del primer punto.

y1 int

El y-coordenado del primer punto.

x2 int

El coordenado x del segundo punto.

y2 int

La coordenada del segundo punto.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pino, float, float, float, float)

Tira una línea que conecta los dos puntos especificados por los pares de coordenadas.

public void DrawLine(Pen pen, float x1, float y1, float x2, float y2)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la línea.

x1 float

El coordenado x del primer punto.

y1 float

El y-coordenado del primer punto.

x2 float

El coordenado x del segundo punto.

y2 float

La coordenada del segundo punto.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(El punto, el punto[])

Tira una serie de segmentos de línea que conectan una serie de estructuras de Aspose.Imaging.Point.

public void DrawLines(Pen pen, Point[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de los segmentos de la línea.

points Point [][]

Array de Aspose.Imaging.Point estructuras que representan los puntos a conectar.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

ArgumentException

La línea de puntos contiene menos de 2 puntos.

DrawLines(Pintura, PointF[])

Tira una serie de segmentos de línea que conectan una serie de estructuras de Aspose.Imaging.PointF.

public void DrawLines(Pen pen, PointF[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de los segmentos de la línea.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que representan los puntos a conectar.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

ArgumentException

La línea de puntos contiene menos de 2 puntos.

DrawPath(Título: GraphicsPath)

Descargar un Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del camino.

path GraphicsPath

Aspose.Imaging.GraphicsPath para dibujar.

Examples

Estos ejemplos hacen uso de la clase GraphicsPath y Graphics para crear y manipular Figuras en una superficie de imagen. El ejemplo crea una nueva imagen (de tipo Tiff), limpia la superficie y atrae caminos con la ayuda de la clase GraphicsPath. Al final, el método DrawPath expuesto por la clase Graphics se llama a rendir los caminos en la superficie.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                     //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                     //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                     graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                     // save all changes.
                                                                                                                                                                                                                                                                                                                                                     image.Save();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

Exceptions

ArgumentNullException

pen’ is null.-or-path’ is null.

DrawPie(Pen, RectangleF, float, float)

Tiene una forma de pie definida por un ellipse especificado por una estructura Aspose.Imaging.RectangleF y dos líneas radiales.

public void DrawPie(Pen pen, RectangleF rect, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la forma de la pie.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa el rectángulo confinante que define la elípsis de la que proviene la forma del pie.

startAngle float

ngulo medido en grados de reloj desde el eixo x hasta el primer lado de la forma de pie.

sweepAngle float

ngulo medido en grados en forma de reloj desde el parámetro startAngle’ hasta el segundo lado de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pino, float, float, float, float, float)

Tiene una forma de pie definida por un ellipse especificado por un par de coordenadas, una anchura, una altura y dos líneas radiales.

public void DrawPie(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la forma de la pie.

x float

El coordenado x del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la forma del pie.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la forma del pie.

width float

La anchura del rectángulo fronterizo que define la elipse de la que viene la forma del pie.

height float

La altura del rectángulo fronterizo que define la elipse de la que viene la forma del pie.

startAngle float

ngulo medido en grados de reloj desde el eixo x hasta el primer lado de la forma de pie.

sweepAngle float

ngulo medido en grados en forma de reloj desde el parámetro startAngle’ hasta el segundo lado de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, rectangle, float, float)

Tiene una forma de pie definida por un ellipse especificado por una estructura de Aspose.Imaging.Rectangle y dos líneas radiales.

public void DrawPie(Pen pen, Rectangle rect, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la forma de la pie.

rect Rectangle

Aspose.Imaging.Rectangle estructura que representa el rectangle fronterizo que define la elípsis de la que proviene la forma de pie.

startAngle float

ngulo medido en grados de reloj desde el eixo x hasta el primer lado de la forma de pie.

sweepAngle float

ngulo medido en grados en forma de reloj desde el parámetro startAngle’ hasta el segundo lado de la forma de pie.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pén, int, int, int, int, int)

Tiene una forma de pie definida por un ellipse especificado por un par de coordenadas, una anchura, una altura y dos líneas radiales.

public void DrawPie(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de la forma de la pie.

x int

El coordenado x del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la forma del pie.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la forma del pie.

width int

La anchura del rectángulo fronterizo que define la elipse de la que viene la forma del pie.

height int

La altura del rectángulo fronterizo que define la elipse de la que viene la forma del pie.

startAngle int

ngulo medido en grados de reloj desde el eixo x hasta el primer lado de la forma de pie.

sweepAngle int

ngulo medido en grados en forma de reloj desde el parámetro startAngle’ hasta el segundo lado de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pintura, PointF[])

Tiene un poligono definido por una serie de estructuras Aspose.Imaging.PointF.

public void DrawPolygon(Pen pen, PointF[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del poligono.

points PointF [][]

Array de Aspose.Imaging.PointF estructuras que representan las verticales del poligono.

Exceptions

ArgumentNullException

pen’ is null.-or-points’ is null.

DrawPolygon(El punto, el punto[])

Es un poligono definido por una serie de estructuras de Aspose.Imaging.Point.

public void DrawPolygon(Pen pen, Point[] points)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del poligono.

points Point [][]

Array de Aspose.Imaging.Point estructuras que representan las verticales del poligono.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, RectangleF)

Toma un rectángulo especificado por una estructura Aspose.Imaging.RectangleF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del rectángulo.

rect RectangleF

Una estructura Aspose.Imaging.RectangleF que representa el rectángulo para dibujar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, rectangulo)

Toma un rectangulo especificado por una estructura de Aspose.Imaging.Rectangle.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del rectángulo.

rect Rectangle

Una estructura de Aspose.Imaging.Rectangle que representa el rectangle para dibujar.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pino, float, float, float, float)

Tira un rectángulo especificado por un par de coordenadas, una anchura y una altura.

public void DrawRectangle(Pen pen, float x, float y, float width, float height)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del rectángulo.

x float

El coordenado x del ángulo superior izquierdo del rectángulo para dibujar.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo para dibujar.

width float

La anchura del rectángulo para dibujar.

height float

La altura del rectángulo para dibujar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, int, int, int, int)

Tira un rectángulo especificado por un par de coordenadas, una anchura y una altura.

public void DrawRectangle(Pen pen, int x, int y, int width, int height)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo del rectángulo.

x int

El coordenado x del ángulo superior izquierdo del rectángulo para dibujar.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo para dibujar.

width int

Ampliación del rectángulo para dibujar.

height int

La altura del rectángulo para dibujar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pén, RectangleF[])

Tiene una serie de rectangulos especificados por las estructuras Aspose.Imaging.RectangleF.

public void DrawRectangles(Pen pen, RectangleF[] rects)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de las líneas de los rectángulos.

rects RectangleF [][]

Array de Aspose.Imaging.RectangleF estructuras que representan los rectangulos para dibujar.

Exceptions

ArgumentNullException

pen’ is null.-or-rects’ is null.

DrawRectangles(Pen, rectangulo[])

Escribe una serie de rectangulos especificados por Aspose.Imaging.Rectangle estructuras.

public void DrawRectangles(Pen pen, Rectangle[] rects)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la anchura y el estilo de las líneas de los rectángulos.

rects Rectangle [][]

Array de Aspose.Imaging.Rectangle estructuras que representan los rectangles para dibujar.

Examples

Este ejemplo muestra la creación y uso de los objetos de Pen. El ejemplo crea una nueva imagen y dibuja Rectangles en la superficie de la imagen.

//Create an instance of BmpOptions and set its various properties
                                                                                                                                       Aspose.Imaging.ImageOptions.BmpOptions bmpOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
                                                                                                                                       bmpOptions.BitsPerPixel = 24;

                                                                                                                                       //Create an instance of FileCreateSource and assign it as Source for the instance of BmpOptions
                                                                                                                                       //Second Boolean parameter determines if the file to be created IsTemporal or not
                                                                                                                                       bmpOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(@"C:\temp\sample.bmp", false);

                                                                                                                                       //Create an instance of Image at specified Path
                                                                                                                                       using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(bmpOptions, 500, 500))
                                                                                                                                       {
                                                                                                                                           //Create an instance of Graphics and initialize it with Image object
                                                                                                                                           Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                           //Clear the Graphics sutface with White Color
                                                                                                                                           graphics.Clear(Aspose.Imaging.Color.White);

                                                                                                                                           //Create an instance of Pen with color Red and width 5
                                                                                                                                           Aspose.Imaging.Pen pen = new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 5f);

                                                                                                                                           //Create an instance of HatchBrush and set its properties
                                                                                                                                           Aspose.Imaging.Brushes.HatchBrush brush = new Aspose.Imaging.Brushes.HatchBrush();
                                                                                                                                           brush.BackgroundColor = Aspose.Imaging.Color.Wheat;
                                                                                                                                           brush.ForegroundColor = Aspose.Imaging.Color.Red;

                                                                                                                                           //Create an instance of Pen
                                                                                                                                           //initialize it with HatchBrush object and width
                                                                                                                                           Aspose.Imaging.Pen brusedpen = new Pen(brush, 5);

                                                                                                                                           //Draw Rectangles by specifying Pen object
                                                                                                                                           graphics.DrawRectangles(pen, new[]
                                                                                                                                           {
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(210, 210), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(110, 110), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(310, 310), new Aspose.Imaging.Size(100, 100))
                                                                                                                                           });

                                                                                                                                           //Draw Rectangles by specifying Pen object
                                                                                                                                           graphics.DrawRectangles(brusedpen, new[]
                                                                                                                                           {
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(310, 110), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(110, 310), new Aspose.Imaging.Size(100, 100))
                                                                                                                                           });

                                                                                                                                           // save all changes.
                                                                                                                                           image.Save();
                                                                                                                                       }

Exceptions

ArgumentNullException

pen’ is null.-or-rects’ is null.

DrawString(Tamaño, Tamaño, Tamaño, Tamaño, Tamaño)

Tira la cadena de texto especificada en la ubicación especificada con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font.

public void DrawString(string s, Font font, Brush brush, float x, float y)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

x float

El coordenado x de la esquina superior izquierda del texto grabado.

y float

El y-coordenado del ángulo superior izquierdo del texto grabado.

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.

DrawString(Tamaño, Tamaño, Brush, PointF)

Tira la cadena de texto especificada en la ubicación especificada con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font.

public void DrawString(string s, Font font, Brush brush, PointF point)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

point PointF

Aspose.Imaging.PointF estructura que especifica el ángulo superior izquierdo del texto grabado.

Examples

Este ejemplo utiliza la clase de gráficos para crear formas primitivas en la superficie de la imagen.Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos de dibujo expuestos por la clase de gráficos

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.

DrawString(Tamaño, Tamaño, Tamaño, Tamaño, Tamaño, Tamaño)

Tira la cadena de texto especificada en la ubicación especificada con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font utilizando los atributos de formatación del especificado Aspose.Imaging.StringFormat.

public void DrawString(string s, Font font, Brush brush, float x, float y, StringFormat format)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

x float

El coordenado x de la esquina superior izquierda del texto grabado.

y float

El y-coordenado del ángulo superior izquierdo del texto grabado.

format StringFormat

Aspose.Imaging.StringFormat que especifica los atributos de formatación, como el espacio de línea y la alineación, que se aplican al texto dibujado.

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.

DrawString(Tamaño, Tamaño, Brush, PointF, StringFormat)

Tira la cadena de texto especificada en la ubicación especificada con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font utilizando los atributos de formatación del especificado Aspose.Imaging.StringFormat.

public void DrawString(string s, Font font, Brush brush, PointF point, StringFormat format)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

point PointF

Aspose.Imaging.PointF estructura que especifica el ángulo superior izquierdo del texto grabado.

format StringFormat

Aspose.Imaging.StringFormat que especifica los atributos de formatación, como el espacio de línea y la alineación, que se aplican al texto dibujado.

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.

DrawString(Título, Título, Brush, RectangleF)

Tira la cadena de texto especificada en el rectángulo especificado con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font.

public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicación del texto grabado.

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.

DrawString(Tamaño, Tamaño, Tamaño, Tamaño, Tamaño)

Tira la cadena de texto especificada en el rectángulo especificado con los objetos especificados Aspose.Imaging.Brush y Aspose.Imaging.Font utilizando los atributos de formatación del especificado Aspose.Imaging.StringFormat.

public void DrawString(string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)

Parameters

s string

Limpieza para dibujar.

font Font

Aspose.Imaging.Font que define el formato de texto de la línea.

brush Brush

Aspose.Imaging.Brush que determina el color y la textura del texto dibujado.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicación del texto grabado.

format StringFormat

Aspose.Imaging.StringFormat que especifica los atributos de formatación, como el espacio de línea y la alineación, que se aplican al texto dibujado.

Exceptions

ArgumentNullException

brush’ is null.-or-s’ is null.-or-brush’ is null.

EndUpdate()

Terminar caching de las operaciones gráficas comenzadas después de que se llamó BeginUpdate. las operaciones gráficas anteriores se aplicarán de inmediato cuando se llama este método.

public void EndUpdate()

FillClosedCurve(Brush y PointF[])

Rellenar el interior de una curva de cordillera cerrada definida por una serie de estructuras Aspose.Imaging.PointF. Este método utiliza una tensión predeterminada de 0.5 y el modo de relleno Aspose.Imaging.FillMode.Alternate.

public void FillClosedCurve(Brush brush, PointF[] points)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillClosedCurve(Brush y PointF[][], El FillMode)

Rellenar el interior de una curva de espina cardinal cerrada definida por una serie de estructuras Aspose.Imaging.PointF utilizando el modo de relleno especificado.

public void FillClosedCurve(Brush brush, PointF[] points, FillMode fillMode)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

fillMode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina cómo se llena la curva.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillClosedCurve(Brush y PointF[][], FillMode, float)

Rellenar el interior de una curva de espina cardinal cerrada definida por una serie de estructuras Aspose.Imaging.PointF utilizando el modo de relleno especificado y la tensión.

public void FillClosedCurve(Brush brush, PointF[] points, FillMode fillmode, float tension)

Parameters

brush Brush

Una Aspose.Imaging.Brush que determina las características del relleno.

points PointF [][]

Array de estructuras Aspose.Imaging.PointF que definen la línea.

fillmode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina cómo se llena la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillClosedCurve(El punto, el punto[])

Rellenar el interior de una curva de cordillera cerrada definida por una serie de estructuras Aspose.Imaging.Point. Este método utiliza una tensión predeterminada de 0.5 y Aspose.Imaging.FillMode.Alternate modo de relleno.

public void FillClosedCurve(Brush brush, Point[] points)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillClosedCurve(El punto, el punto[][], El FillMode)

Rellenar el interior de una curva de espina cardinal cerrada definida por una serie de estructuras Aspose.Imaging.Point utilizando el modo de relleno especificado.

public void FillClosedCurve(Brush brush, Point[] points, FillMode fillmode)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

fillmode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina cómo se llena la curva.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillClosedCurve(El punto, el punto[][], FillMode, float)

Rellenar el interior de una curva de espina cardinal cerrada definida por una serie de estructuras Aspose.Imaging.Point utilizando el modo de relleno especificado y la tensión.

public void FillClosedCurve(Brush brush, Point[] points, FillMode fillmode, float tension)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points Point [][]

Array de Aspose.Imaging.Point estructuras que definen la línea.

fillmode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina cómo se llena la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensión de la curva.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillEllipse(Cortesía, RectangleF)

Cumple el interior de una elípsis definida por un rectángulo limitante especificado por una estructura Aspose.Imaging.RectangleF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa el rectángulo confinante que define ellipse.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(La flota, la flota, la flota, la flota)

Cumple el interior de un ellipse definido por un rectángulo limitante especificado por un par de coordenadas, una anchura y una altura.

public void FillEllipse(Brush brush, float x, float y, float width, float height)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x float

El coordenado x del ángulo superior izquierdo del rectángulo que define el elípsis.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo que define el elípsis.

width float

La anchura del rectángulo que define el elípsis.

height float

La altura del rectángulo fronterizo que define la elipse.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush y Rectangle)

Cumple el interior de una elípsis definida por un rectángulo limitante especificado por una estructura de Aspose.Imaging.Rectángulo.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect Rectangle

Aspose.Imaging.Rectangle estructura que representa el rectangle fronterizo que define ellipse.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush, int, int, int, int)

Cumple el interior de un ellipse definido por un rectángulo limitante especificado por un par de coordenadas, una anchura y una altura.

public void FillEllipse(Brush brush, int x, int y, int width, int height)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x int

El coordenado x del ángulo superior izquierdo del rectángulo que define el elípsis.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo que define el elípsis.

width int

La anchura del rectángulo que define el elípsis.

height int

La altura del rectángulo fronterizo que define la elipse.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Brush y GraphicsPath)

Cumple el interior de un Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

path GraphicsPath

Aspose.Imaging.GraphicsPath que representa el camino para llenar.

Exceptions

ArgumentNullException

brush’ is null.-or-path’ is null.

FillPie(Brush, rectangle, float, float)

Llega el interior de una sección de pie definida por un ellipse especificado por una estructura Aspose.Imaging.RectangleF y dos líneas radiales.

public void FillPie(Brush brush, Rectangle rect, float startAngle, float sweepAngle)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect Rectangle

Aspose.Imaging.Rectangle estructura que representa el rectangle fronterizo que define la elípsis de la que viene la sección de pie.

startAngle float

ngulo en grados medido en forma de reloj desde el eixo x hasta el primer lado de la sección de pie.

sweepAngle float

ngulo en grados medido en forma de reloj desde el parámetro startAngle’ al segundo lado de la sección de pie.

Examples

El siguiente ejemplo muestra cómo componer una imagen GIF animada de bloques GIF individuales.

string dir = "c:\\temp\\";

                                                                                                       // Create a GIF image 100 x 100 px.
                                                                                                       // The first block is fully black by default.
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                                       {
                                                                                                           // The first circle is red
                                                                                                           Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                           // The second circle is black
                                                                                                           Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                           // Gradually inscrease the angle of the red arc shape.
                                                                                                           for (int angle = 10; angle <= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                           for (int angle = 10; angle <= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush2, block.Bounds, 0, angle);
                                                                                                               gr.FillPie(brush1, block.Bounds, angle, 360 - angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           gifImage.Save(dir + "animated_radar.gif");
                                                                                                       }

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Brush, RectangleF, float, float)

Llega el interior de una sección de pie definida por un ellipse especificado por una estructura Aspose.Imaging.RectangleF y dos líneas radiales.

public void FillPie(Brush brush, RectangleF rect, float startAngle, float sweepAngle)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa el rectángulo confinante que define la elípsis de la que viene la sección de pie.

startAngle float

ngulo en grados medido en forma de reloj desde el eixo x hasta el primer lado de la sección de pie.

sweepAngle float

ngulo en grados medido en forma de reloj desde el parámetro startAngle’ al segundo lado de la sección de pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(La flota, la flota, la flota, la flota, la flota, la flota)

Cumple el interior de una sección de pie definida por una elipse especificada por un par de coordenadas, una anchura, una altura y dos líneas radiales.

public void FillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x float

El coordenado x del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la sección de pie.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo confinante que define la elipse de la que viene la sección de pie.

width float

La anchura del rectángulo fronterizo que define la elipse de la que viene la sección de pie.

height float

La altura del rectángulo fronterizo que define la elipse de la que viene la sección de pie.

startAngle float

ngulo en grados medido en forma de reloj desde el eixo x hasta el primer lado de la sección de pie.

sweepAngle float

ngulo en grados medido en forma de reloj desde el parámetro startAngle’ al segundo lado de la sección de pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Brush, int, int, int, int, int)

Cumple el interior de una sección de pie definida por una elipse especificada por un par de coordenadas, una anchura, una altura y dos líneas radiales.

public void FillPie(Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x int

El coordenado x del ángulo superior izquierdo del rectángulo que define la elípsis de la que viene la sección de pie.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo confinante que define la elipse de la que viene la sección de pie.

width int

La anchura del rectángulo fronterizo que define la elipse de la que viene la sección de pie.

height int

La altura del rectángulo fronterizo que define la elipse de la que viene la sección de pie.

startAngle int

ngulo en grados medido en forma de reloj desde el eixo x hasta el primer lado de la sección de pie.

sweepAngle int

ngulo en grados medido en forma de reloj desde el parámetro startAngle’ al segundo lado de la sección de pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush y PointF[])

Cumple el interior de un poligono definido por una serie de puntos especificados por las estructuras Aspose.Imaging.PointF y Aspose.Imaging.FillMode.Alternate.

public void FillPolygon(Brush brush, PointF[] points)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points PointF [][]

Array de Aspose.Imaging.PointF estructuras que representan las verticales del poligono para llenar.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillPolygon(Brush y PointF[][], El FillMode)

Rellenar el interior de un poligono definido por una serie de puntos especificados por las estructuras Aspose.Imaging.PointF utilizando el modo de relleno especificado.

public void FillPolygon(Brush brush, PointF[] points, FillMode fillMode)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points PointF [][]

Array de Aspose.Imaging.PointF estructuras que representan las verticales del poligono para llenar.

fillMode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina el estilo del relleno.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillPolygon(El punto, el punto[])

Cumple el interior de un poligono definido por una serie de puntos especificados por Aspose.Imaging.Point estructuras y Aspose.Imaging.FillMode.Alternate.

public void FillPolygon(Brush brush, Point[] points)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points Point [][]

Array de Aspose.Imaging.Point estructuras que representan las verticales del poligono para llenar.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillPolygon(El punto, el punto[][], El FillMode)

Rellenar el interior de un poligono definido por una serie de puntos especificados por Aspose.Imaging.Point estructuras utilizando el modo de relleno especificado.

public void FillPolygon(Brush brush, Point[] points, FillMode fillMode)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

points Point [][]

Array de Aspose.Imaging.Point estructuras que representan las verticales del poligono para llenar.

fillMode FillMode

Miembro de la enumeración Aspose.Imaging.FillMode que determina el estilo del relleno.

Exceptions

ArgumentNullException

brush’ is null.-or-points’ is null.

FillRectangle(Brush y Rectangle)

Cumple el interior de un rectangulo especificado por una estructura de Aspose.Imaging.Rectangle.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect Rectangle

Aspose.Imaging.Rectangle estructura que representa el rectangle para llenar.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Cortesía, RectangleF)

Cumple el interior de un rectángulo especificado por una estructura Aspose.Imaging.RectangleF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa el rectangle para llenar.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(La flota, la flota, la flota, la flota)

Cumple el interior de un rectángulo especificado por un par de coordenadas, una anchura y una altura.

public void FillRectangle(Brush brush, float x, float y, float width, float height)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x float

El coordenado x del ángulo superior izquierdo del rectángulo para llenar.

y float

El y-coordenado del ángulo superior izquierdo del rectángulo para llenar.

width float

Ampliación del rectángulo para llenar.

height float

La altura del rectángulo para llenar.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, int, int, int, int)

Cumple el interior de un rectángulo especificado por un par de coordenadas, una anchura y una altura.

public void FillRectangle(Brush brush, int x, int y, int width, int height)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

x int

El coordenado x del ángulo superior izquierdo del rectángulo para llenar.

y int

El y-coordenado del ángulo superior izquierdo del rectángulo para llenar.

width int

Ampliación del rectángulo para llenar.

height int

La altura del rectángulo para llenar.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush y Rectangle[])

Cumple los interiores de una serie de rectangulos especificados por Aspose.Imaging.Rectangle estructuras.

public void FillRectangles(Brush brush, Rectangle[] rects)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rects Rectangle [][]

Array de Aspose.Imaging.Rectangle estructuras que representan los rectangles para llenar.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Cortesía, RectangleF[])

Cumple los interiores de una serie de rectangulos especificados por las estructuras Aspose.Imaging.RectangleF.

public void FillRectangles(Brush brush, RectangleF[] rects)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

rects RectangleF [][]

Array de Aspose.Imaging.Rectangle estructuras que representan los rectangles para llenar.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Región)

Cumple el interior de un Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush que determina las características del relleno.

region Region

Aspose.Imaging.Región que representa la zona a cubrir.

Exceptions

ArgumentNullException

brush’ is null.-or-region’ is null.

~Graphics()

protected ~Graphics()

MeasureString(Tamaño, Tamaño, Tamaño, Tamaño)

Medir la cadena de texto especificada con los parámetros especificados

public SizeF MeasureString(string text, Font font, SizeF layoutArea, StringFormat stringFormat)

Parameters

text string

El texto para medir.

font Font

La letra para medir.

layoutArea SizeF

El área de layout.

stringFormat StringFormat

El formato de string.

Returns

SizeF

Tamaño en píxeles de string de texto medido

MultiplyTransform(Matrix)

Se multiplica el Aspose.Imaging.Matrix que representa la transformación geométrica local de este Aspose.Imaging.Grafica por el especificado Aspose.Imaging.Matrix prepondiendo el especificado Aspose.Imaging.Matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

El Aspose.Imaging.Matrix por el que multiplicar la transformación geométrica.

MultiplyTransform(Matrix y MatrixOrder)

Multiplica el Aspose.Imaging.Matrix que representa la transformación geométrica local de este Aspose.Imaging.Graphics por el especificado Aspose.Imaging.Matrix en el orden especificado.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

El Aspose.Imaging.Matrix por el que multiplicar la transformación geométrica.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica en qué fin multiplicar las dos matrices.

ResetTransform()

Resete el Aspose.Imaging.Graphics.Transforma la propiedad en identidad.

public void ResetTransform()

RotateTransform(float)

Rotará la transformación geométrica local por la cantidad especificada.Este método previene la rotación a la transformación.

public void RotateTransform(float angle)

Parameters

angle float

El ángulo de la rotación.

RotateTransform(Título: MatrixOrder)

Rotará la transformación geométrica local por la cantidad especificada en el orden especificado.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

El ángulo de la rotación.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica si añadir o prependir la matriz de rotación.

ScaleTransform(Float y Float)

Escala la transformación geométrica local por las cantidades especificadas.Este método predomina la matriz de escalada a la transformación.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

La cantidad por la que escalar la transformación en la dirección x-axis.

sy float

La cantidad por la que escalar la transformación en la dirección y-axis.

ScaleTransform(Float, Float y MatrixOrder)

Escala la transformación geométrica local por las cantidades especificadas en el orden especificado.

public void ScaleTransform(float sx, float sy, MatrixOrder order)

Parameters

sx float

La cantidad por la que escalar la transformación en la dirección x-axis.

sy float

La cantidad por la que escalar la transformación en la dirección y-axis.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica si añadir o prependir la matriz de escalada.

TranslateTransform(Float y Float)

Traducir la transformación geométrica local por las dimensiones especificadas.Este método previene la traducción a la transformación.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

El valor de la traducción en x.

dy float

El valor de la traducción en y.

TranslateTransform(Float, Float y MatrixOrder)

Traducir la transformación geométrica local por las dimensiones especificadas en el orden especificado.

public void TranslateTransform(float dx, float dy, MatrixOrder order)

Parameters

dx float

El valor de la traducción en x.

dy float

El valor de la traducción en y.

order MatrixOrder

La orden (prepend o append) en la que aplicar la traducción.

 Español