Class Graphics

Class Graphics

Nome do espaço: Aspose.Imaging Assembleia: Aspose.Imaging.dll (25.4.0)

Representa os gráficos de acordo com o motor gráfico usado na assembleia atual.

public sealed class Graphics

Inheritance

object Graphics

Membros herdados

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

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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 uma nova instância da classe Aspose.Imaging.Graphics.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

A imagem da fonte.

Properties

Clip

Receba ou coloca a região de clipe.

public Region Clip { get; set; }

Valor da propriedade

Region

CompositingQuality

Obter ou definir a qualidade de composição.

public CompositingQuality CompositingQuality { get; set; }

Valor da propriedade

CompositingQuality

Dpix

Obtenha a resolução horizontal deste Aspose.Imaging.Graphics.

public float DpiX { get; }

Valor da propriedade

float

Dpião

Obtenha a resolução vertical deste Aspose.Imaging.Graphics.

public float DpiY { get; }

Valor da propriedade

float

Image

Obtenha a imagem.

public Image Image { get; }

Valor da propriedade

Image

InterpolationMode

Obter ou definir o modo de interpolação.

public InterpolationMode InterpolationMode { get; set; }

Valor da propriedade

InterpolationMode

IsInBeginUpdateCall

Obtenha um valor indicando se o gráfico está no estado de chamada BeginUpdate.

public bool IsInBeginUpdateCall { get; }

Valor da propriedade

bool

PageScale

Obter ou definir a escala entre unidades mundiais e unidades de página para este Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Valor da propriedade

float

PageUnit

Obter ou definir a unidade de medida usada para as coordenadas da página neste Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Valor da propriedade

GraphicsUnit

PaintableImageOptions

Obter ou definir opções de imagem, usadas para criar imagens de vácuo pintáveis para desenhar.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valor da propriedade

ImageOptionsBase

SmoothingMode

Obter ou definir o modo de suavidade.

public SmoothingMode SmoothingMode { get; set; }

Valor da propriedade

SmoothingMode

TextRenderingHint

Recebe ou coloca o texto rendering hint.

public TextRenderingHint TextRenderingHint { get; set; }

Valor da propriedade

TextRenderingHint

Transform

Obtenha ou coloca uma cópia da transformação geométrica do mundo para este Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Valor da propriedade

Matrix

Methods

BeginUpdate()

Os efeitos gráficos aplicados posteriormente não serão aplicados imediatamente, mas o EndUpdate irá causar a aplicação de todos os efeitos ao mesmo tempo.

public void BeginUpdate()

Remarks

Observe que os efeitos após a chamada de StartUpdate não serão aplicados se o EndUpdate não for chamado.

Clear(Color)

Limpe a superfície gráfica usando a cor especificada.

public void Clear(Color color)

Parameters

color Color

A cor para limpar a superfície gráfica por.

Examples

Esses exemplos usam a classe GraphicsPath e Graphics para criar e manipular Figuras em uma superfície da imagem. Exemplo cria uma nova imagem (do tipo Tiff), limpa a superfície e tira caminhos com a ajuda da classe GraphicsPath. No final, o método DrawPath exposto pela classe Graphics é chamado para render os caminhos na superfície.

//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();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Flóia, Flóia, Flóia, Flóia, Flóia)

Trata-se de um arco que representa uma porção de um elípcio especificado por um par de coordenadas, uma largura e uma 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 a cor, largura e estilo do arco.

x float

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y float

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width float

A largura do rectangulo que define a elípcia.

height float

A altura do rectangulo que define a elípcia.

startAngle float

O ângulo em graus é medido de forma horária do eixo x até o ponto de partida do arco.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para terminar o ponto do ângulo.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Desenha um arco que representa uma porção de um elípcio especificado por uma estrutura Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do arco.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que define os limites da elípcia.

startAngle float

O ângulo em graus é medido de forma horária do eixo x até o ponto de partida do arco.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para terminar o ponto do ângulo.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pen, int, int, int, int, int, int)

Trata-se de um arco que representa uma porção de um elípcio especificado por um par de coordenadas, uma largura e uma 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 a cor, largura e estilo do arco.

x int

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y int

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width int

A largura do rectangulo que define a elípcia.

height int

A altura do rectangulo que define a elípcia.

startAngle int

O ângulo em graus é medido de forma horária do eixo x até o ponto de partida do arco.

sweepAngle int

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para terminar o ponto do ângulo.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, rectangle, float, float)

Desenha um arco que representa uma porção de um elípcio especificado por uma estrutura Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do arco.

rect Rectangle

Aspose.Imaging.RectangleF estrutura que define os limites da elípcia.

startAngle float

O ângulo em graus é medido de forma horária do eixo x até o ponto de partida do arco.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para terminar o ponto do ângulo.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Flóia, Flóia, Flóia, Flóia, Flóia, Flóia, Flóia)

Desenha uma linha Bézier definida por quatro pares ordenados de coordenadas que representam pontos.

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 a cor, largura e estilo da curva.

x1 float

O coordenado x do ponto de partida da curva.

y1 float

o coordenado do ponto de partida da curva.

x2 float

O coordenado x do primeiro ponto de controle da curva.

y2 float

O coordenado y do primeiro ponto de controle da curva.

x3 float

O coordenado x do segundo ponto de controle da curva.

y3 float

o coordenado do segundo ponto de controle da curva.

x4 float

A coordenada x do ponto final da curva.

y4 float

O y-coordenado do ponto final da curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pen, PointF, PointF e PointF)

Desenha uma linha Bézier definida por quatro estruturas Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da curva.

pt1 PointF

Aspose.Imaging.PointF estrutura que representa o ponto de partida da curva.

pt2 PointF

Aspose.Imaging.PointF estrutura que representa o primeiro ponto de controle para a curva.

pt3 PointF

Aspose.Imaging.PointF estrutura que representa o segundo ponto de controle para a curva.

pt4 PointF

Aspose.Imaging.PointF estrutura que representa o ponto final da curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pen, ponto, ponto, ponto e ponto)

Desenha uma linha Bézier definida por quatro estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen estrutura que determina a cor, largura e estilo da curva.

pt1 Point

Aspose.Imaging.Point estrutura que representa o ponto de partida da curva.

pt2 Point

Aspose.Imaging.Point estrutura que representa o primeiro ponto de controle para a curva.

pt3 Point

Aspose.Imaging.Point estrutura que representa o segundo ponto de controle para a curva.

pt4 Point

Aspose.Imaging.Point estrutura que representa o ponto final da curva.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pessoa, ponto[])

Desenha uma série de linhas Bézier de uma série de estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que representam os pontos que determinam a curva.

Exceptions

ArgumentNullException

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

DrawBeziers(Pessoa, PointF[])

Desenha uma série de linhas Bézier de uma série de estruturas Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que representam os pontos que determinam a curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pessoa, PointF[])

Desenha uma linha cardinal fechada definida por uma série de estruturas Aspose.Imaging.PointF. Este método usa uma tensão padrão de 0,5 e Aspose.Imaging.FillMode.Alternate modo de enchimento.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pessoa, PointF[ ], A flota)

Desenha uma linha cardinal fechada definida por uma série de estruturas Aspose.Imaging.PointF usando uma tensão especificada. Este método usa um modo de enchimento padrão Aspose.Imaging.FillMode.Alternate.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pessoa, ponto[])

Trata-se de uma linha cardinal fechada definida por uma série de estruturas Aspose.Imaging.Point. Este método usa uma tensão padrão de 0,5 e Aspose.Imaging.FillMode.Alternate modo de enchimento.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pessoa, ponto[ ], A flota)

Desenha uma linha cardinal fechada definida por uma série de estruturas Aspose.Imaging.Point usando uma tensão especificada. Este método usa um modo de enchimento padrão Aspose.Imaging.FillMode.Alternate.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawCurve(Pessoa, PointF[])

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.PointF. Este método usa uma tensão padrão de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

Exceptions

ArgumentNullException

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

DrawCurve(Pessoa, PointF[ ], A flota)

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.PointF usando uma tensão especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que representam os pontos que definem a curva.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawCurve(Pessoa, PointF[ ], Por isso, int)

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.PointF. O desenho começa com o início da série.Este método usa uma tensão padrão de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

offset int

Desligue do primeiro elemento na sequência do parâmetro points’ para o ponto de partida na curva.

numberOfSegments int

Número de segmentos após o ponto de partida para incluir na curva.

Exceptions

ArgumentNullException

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

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

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.PointF usando uma tensão especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

offset int

Desligue do primeiro elemento na sequência do parâmetro points’ para o ponto de partida na curva.

numberOfSegments int

Número de segmentos após o ponto de partida para incluir na curva.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawCurve(Pessoa, ponto[])

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pessoa, ponto[ ], A flota)

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.Point usando uma tensão especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawCurve(Pessoa, ponto[ ], int , int , float)

Desenha uma linha cardinal através de uma série especificada de estruturas Aspose.Imaging.Point usando uma tensão especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e altura da curva.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

offset int

Desligue do primeiro elemento na sequência do parâmetro points’ para o ponto de partida na curva.

numberOfSegments int

Número de segmentos após o ponto de partida para incluir na curva.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

DrawEllipse(Pênis, RectangleF)

Desenha uma elípsia definida por um limite Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da elípsia.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que define os limites da elípcia.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, float, float, float, float)

Trata-se de uma elípcia definida por um rectangulo limitante especificado por um par de coordenadas, uma altura e uma largura.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da elípsia.

x float

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y float

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width float

A largura do rectangulo que define a elípcia.

height float

A altura do rectangulo que define a elípcia.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pênis, Rectangle)

Trata-se de uma elípsia especificada por uma estrutura limitante Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da elípsia.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que define os limites da elípcia.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pen, int, int, int, int, int)

Trata-se de uma elípcia definida por um rectangulo limitante especificado por um par de coordenadas, uma altura e uma largura.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da elípsia.

x int

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y int

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width int

A largura do rectangulo que define a elípcia.

height int

A altura do rectangulo que define a elípcia.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Imagem, PointF)

Desenha o Aspose.Imaging.Graphics.Image especificado, usando o seu tamanho físico original, na localização especificada.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

A imagem para desenhar.

point PointF

Aspose.Imaging.PointF estrutura que representa o canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Float, Float)

Desenha o Aspose.Imaging.Graphics.Image especificado, usando o seu tamanho físico original, na localização especificada.

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

Parameters

sourceImage Image

A imagem para desenhar.

x float

O coordenado x do canto superior esquerdo da imagem desenhada.

y float

O y-coordenado do canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, RectangleF)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

A imagem para desenhar.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que especifica a localização e tamanho da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Rectangle, GraphicsUnit)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectDestination Rectangle

direção do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, RectangleF, GraphicsUnit)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectDestination RectangleF

direção do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Rectangle, GraphicsUnit, Atributos da imagem)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectDestination Rectangle

direção do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

imageAttributes ImageAttributes

A imagem atribua.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, RectangleF, GraphicsUnit, ImageAttributes)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectDestination RectangleF

A direção direcionada para atrair.

graphicsUnit GraphicsUnit

A unidade gráfica.

imageAttributes ImageAttributes

A imagem atribua.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Rectangle, Rectangle, GraphicsUnit)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectSource Rectangle

A fonte do rect.

rectDestination Rectangle

Direito do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, RectangleF, RectangleF, GraphicsUnit)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectSource RectangleF

A fonte do rect.

rectDestination RectangleF

Direito do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectSource Rectangle

A fonte do rect.

rectDestination Rectangle

Direito do destino.

graphicsUnit GraphicsUnit

A unidade gráfica.

imageAttributes ImageAttributes

A imagem atribua.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

rectSource RectangleF

A fonte rectangular.

rectDestination RectangleF

direção do destino.

graphicsUnit GraphicsUnit

A unidade gráfica para uso.

imageAttributes ImageAttributes

A imagem atribui a utilização.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, ponto[])

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints Point [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

DrawImage(Imagem, ponto[ ], Direção Rectangle)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints Point [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect Rectangle

A fonte rectangular.

DrawImage(Imagem, ponto[ ], Rectangle, GraphicsUnit)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints Point [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect Rectangle

A fonte rectangular.

srcUnit GraphicsUnit

unidades de medida.

DrawImage(Imagem, ponto[ ], Rectangle, GraphicsUnit, Atributos de imagem)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints Point [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect Rectangle

A fonte rectangular.

srcUnit GraphicsUnit

unidades de medida.

imageAttributes ImageAttributes

A imagem atribua.

DrawImage(Imagem, PointF[])

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints PointF [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

Exceptions

ArgumentNullException

Imagem

DrawImage(Imagem, PointF[ ], e RectangleF)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints PointF [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect RectangleF

A fonte rectangular.

DrawImage(Imagem, PointF[ ], RectangleF, GraphicsUnit)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints PointF [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect RectangleF

A fonte rectangular.

srcUnit GraphicsUnit

unidades de medida.

DrawImage(Imagem, PointF[ ], RectangleF, GraphicsUnit, Atributos de imagem)

Tire a porção especificada da imagem ’ na localização especificada e com o tamanho especificado.

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

Parameters

image Image

A imagem para desenhar.

destPoints PointF [ ]

Um conjunto de três estruturas PointF que definem um paralelograma.

srcRect RectangleF

A fonte rectangular.

srcUnit GraphicsUnit

unidades de medida.

imageAttributes ImageAttributes

A imagem atribua.

DrawImage(Imagem, float, float, float, float)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

x float

O coordenado x do canto superior esquerdo da imagem desenhada.

y float

O y-coordenado do canto superior esquerdo da imagem desenhada.

width float

amplitude da imagem desenhada.

height float

altura da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, ponto)

Desenha o Aspose.Imaging.Graphics.Image especificado, usando o seu tamanho físico original, na localização especificada.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

A imagem para desenhar.

point Point

Aspose.Imaging.Point estrutura que representa a localização do canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, int, int)

Desenha a imagem especificada, usando o seu tamanho físico original, na localização especificada por um par de coordenadas.

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

Parameters

sourceImage Image

A imagem para desenhar.

x int

O coordenado x do canto superior esquerdo da imagem desenhada.

y int

O y-coordenado do canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, Rectangle)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A imagem para desenhar.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que especifica a localização e tamanho da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagem, int, int, int, int)

Desenha o Aspose.Imaging.Graphics.Image especificado no local especificado e com o tamanho especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

x int

O coordenado x do canto superior esquerdo da imagem desenhada.

y int

O y-coordenado do canto superior esquerdo da imagem desenhada.

width int

amplitude da imagem desenhada.

height int

altura da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagem, ponto)

Desenha uma imagem especificada usando seu tamanho físico original em um local especificado.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

A imagem para desenhar.

point Point

Aspose.Imaging.Point estrutura que especifica o canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagem, int, int)

Desenha a imagem especificada usando o seu tamanho físico original na localização especificada por um par de coordenadas.

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

Parameters

sourceImage Image

A imagem para desenhar.

x int

O coordenado x do canto superior esquerdo da imagem desenhada.

y int

O y-coordenado do canto superior esquerdo da imagem desenhada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagem, Rectangle)

Desenha uma imagem especificada usando seu tamanho físico original em um local especificado.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A imagem para desenhar.

rect Rectangle

Aspose.Imaging.Rectangle que especifica o canto superior esquerdo da imagem desenhada.As propriedades X e Y do rectangle especificam o canto superior esquerdo.As propriedades de largura e altura são ignoradas.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagem, int, int, int, int)

Desenha uma imagem especificada usando seu tamanho físico original em um local especificado.

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

Parameters

sourceImage Image

A imagem para desenhar.

x int

O coordenado x do canto superior esquerdo da imagem desenhada.

y int

O y-coordenado do canto superior esquerdo da imagem desenhada.

width int

O parâmetro não é usado.

height int

O parâmetro não é usado.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Imagem, Rectangle)

Tire a imagem especificada sem escalar e clipe-a, se necessário, para se encaixar no rectangulo especificado.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A imagem para desenhar.

rect Rectangle

O Aspose.Imaging.Rectangle em que desenhar a imagem.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Ponto, Ponto e Ponto)

Trata-se de uma linha que liga duas estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da linha.

point1 Point

Aspose.Imaging.Point estrutura que representa o primeiro ponto para se conectar.

point2 Point

Aspose.Imaging.Point estrutura que representa o segundo ponto para se conectar.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pen, PointF e PointF)

Trata-se de uma linha que liga duas estruturas Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da linha.

point1 PointF

Aspose.Imaging.PointF estrutura que representa o primeiro ponto para se conectar.

point2 PointF

Aspose.Imaging.PointF estrutura que representa o segundo ponto para se conectar.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, int, int, int, int, int)

Desenha uma linha que liga os dois pontos especificados pelos pares de coordenadas.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da linha.

x1 int

A coordenada x do primeiro ponto.

y1 int

A coordenada do primeiro ponto.

x2 int

A coordenada x do segundo ponto.

y2 int

A coordenada do segundo ponto.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, float, float, float, float)

Desenha uma linha que liga os dois pontos especificados pelos pares de coordenadas.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da linha.

x1 float

A coordenada x do primeiro ponto.

y1 float

A coordenada do primeiro ponto.

x2 float

A coordenada x do segundo ponto.

y2 float

A coordenada do segundo ponto.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Pessoa, ponto[])

Desenha uma série de segmentos de linha que conectam uma série de estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo dos segmentos da linha.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que representam os pontos para se conectar.

Exceptions

ArgumentNullException

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

ArgumentException

A linha de pontos contém menos de 2 pontos.

DrawLines(Pessoa, PointF[])

Desenha uma série de segmentos de linha que conectam uma série de estruturas Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo dos segmentos da linha.

points PointF [ ]

Uma série de estruturas Aspose.Imaging.PointF que representam os pontos para se conectar.

Exceptions

ArgumentNullException

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

ArgumentException

A linha de pontos contém menos de 2 pontos.

DrawPath(Pentecostes, GraphicsPath)

Faça uma imagem.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do caminho.

path GraphicsPath

Aspose.Imaging.GraphicsPath para desenhar.

Examples

Esses exemplos usam a classe GraphicsPath e Graphics para criar e manipular Figuras em uma superfície da imagem. Exemplo cria uma nova imagem (do tipo Tiff), limpa a superfície e tira caminhos com a ajuda da classe GraphicsPath. No final, o método DrawPath exposto pela classe Graphics é chamado para render os caminhos na superfície.

//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)

Trata-se de uma forma de pé definida por uma elípsia especificada por uma estrutura Aspose.Imaging.RectangleF e duas linhas radiais.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da forma do pie.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que representa o rectangulo de ligação que define a elípsia de que a forma do pé vem.

startAngle float

O ângulo é medido em graus de relógio do eixo x até o primeiro lado da forma do pie.

sweepAngle float

O ângulo medido em graus de modo horário do startParâmetro do ângulo para o segundo lado da forma do pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Flóia, Flóia, Flóia, Flóia, Flóia)

Trata-se de uma forma de pé definida por um elípcio especificado por um par de coordenadas, uma largura, uma altura e duas linhas radiais.

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 a cor, largura e estilo da forma do pie.

x float

O coordenado x do canto superior esquerdo do rectangulo de limiar que define a elípsia da qual a forma do pé vem.

y float

O y-coordenado do canto superior esquerdo do rectangulo de ligação que define a elípsia da qual a forma do pé vem.

width float

A largura do rectangulo limitante que define a elípsia da qual a forma do pé vem.

height float

A altura do rectangulo de limiar que define a elípsia de que a forma do pé vem.

startAngle float

O ângulo é medido em graus de relógio do eixo x até o primeiro lado da forma do pie.

sweepAngle float

O ângulo medido em graus de modo horário do startParâmetro do ângulo para o segundo lado da forma do pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, rectangle, float, float)

Trata-se de uma forma de pé definida por uma elípsia especificada por uma estrutura de Aspose.Imaging.Rectangle e duas linhas radiais.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo da forma do pie.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que representa o rectangle de limiar que define a elípsia de que a forma do pé vem.

startAngle float

O ângulo é medido em graus de relógio do eixo x até o primeiro lado da forma do pie.

sweepAngle float

O ângulo medido em graus de modo horário do startParâmetro do ângulo para o segundo lado da forma do pie.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pen, int, int, int, int, int, int)

Trata-se de uma forma de pé definida por um elípcio especificado por um par de coordenadas, uma largura, uma altura e duas linhas radiais.

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 a cor, largura e estilo da forma do pie.

x int

O coordenado x do canto superior esquerdo do rectangulo de limiar que define a elípsia da qual a forma do pé vem.

y int

O y-coordenado do canto superior esquerdo do rectangulo de ligação que define a elípsia da qual a forma do pé vem.

width int

A largura do rectangulo limitante que define a elípsia da qual a forma do pé vem.

height int

A altura do rectangulo de limiar que define a elípsia de que a forma do pé vem.

startAngle int

O ângulo é medido em graus de relógio do eixo x até o primeiro lado da forma do pie.

sweepAngle int

O ângulo medido em graus de modo horário do startParâmetro do ângulo para o segundo lado da forma do pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pessoa, PointF[])

Trata-se de um polígono definido por uma série de estruturas Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do poligon.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que representam as vertices do poligon.

Exceptions

ArgumentNullException

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

DrawPolygon(Pessoa, ponto[])

Trata-se de um polígono definido por uma série de estruturas Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do poligon.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que representam as vertices do poligono.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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ênis, RectangleF)

Desenha um rectangulo especificado por uma estrutura Aspose.Imaging.RectangleF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Um Aspose.Imaging.Pen que determina a cor, largura e estilo do rectangulo.

rect RectangleF

Uma estrutura Aspose.Imaging.RectangleF que representa o rectangle para desenhar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pênis, Rectangle)

Desenha um rectangulo especificado por uma estrutura Aspose.Imaging.Rectangle.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Um Aspose.Imaging.Pen que determina a cor, largura e estilo do rectangulo.

rect Rectangle

Uma estrutura de Aspose.Imaging.Rectangle que representa o rectangle para desenhar.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Pen, float, float, float, float)

Trata-se de um rectangulo especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

pen Pen

Um Aspose.Imaging.Pen que determina a cor, largura e estilo do rectangulo.

x float

O coordenado x do canto superior esquerdo do rectangulo para desenhar.

y float

O y-coordenado do canto superior esquerdo do rectangulo para desenhar.

width float

A largura do rectangulo para desenhar.

height float

A altura do rectangulo para desenhar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, int, int, int, int, int)

Trata-se de um rectangulo especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo do rectangulo.

x int

O coordenado x do canto superior esquerdo do rectangulo para desenhar.

y int

O y-coordenado do canto superior esquerdo do rectangulo para desenhar.

width int

largura do rectangulo para desenhar.

height int

A altura do rectangulo para desenhar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pênis, RectangleF[])

Desenha uma série de rectangulos especificados pelas estruturas Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo das folhas dos rectangulos.

rects RectangleF [ ]

Array de Aspose.Imaging.RectangleF estruturas que representam os rectangulos para desenhar.

Exceptions

ArgumentNullException

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

DrawRectangles(Pênis, Rectangle[])

Desenha uma série de rectangulos especificados por Aspose.Imaging.Rectangle estruturas.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina a cor, largura e estilo das folhas dos rectangulos.

rects Rectangle [ ]

Array de Aspose.Imaging.Rectangle estruturas que representam os rectangles para desenhar.

Examples

Este exemplo mostra a criação e uso de objetos Pen. O exemplo cria uma nova imagem e desenha Rectangles na superfície da imagem.

//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(Fonte, Fonte, Fonte, Fonte, Fonte, Fonte)

Tire a linha de texto especificada na localização especificada com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

x float

O coordenado x do canto superior esquerdo do texto desenhado.

y float

O coordenado y do canto superior esquerdo do texto desenhado.

Exceptions

ArgumentNullException

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

DrawString(Fonte, Fonte, Brush e PointF)

Tire a linha de texto especificada na localização especificada com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

point PointF

Aspose.Imaging.PointF estrutura que especifica o canto superior esquerdo do texto desenhado.

Examples

Para demonstrar a operação, o exemplo cria uma nova imagem em formato PNG e desenha formas primitivas na superfície da imagem usando métodos de desenho expostos pela classe gráfica.

//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(Fonte, Fonte, Fonte, Fonte, Fonte, Fonte)

Tire a linha de texto especificada no local especificado com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados usando os atributos de formatação do Aspose.Imaging.StringFormat especificado.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

x float

O coordenado x do canto superior esquerdo do texto desenhado.

y float

O coordenado y do canto superior esquerdo do texto desenhado.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributos de formatação, como espaçamento de linha e alinhamento, que são aplicados ao texto desenhado.

Exceptions

ArgumentNullException

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

DrawString(Fonte, Fonte, Brush, PointF, StringFormat)

Tire a linha de texto especificada no local especificado com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados usando os atributos de formatação do Aspose.Imaging.StringFormat especificado.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

point PointF

Aspose.Imaging.PointF estrutura que especifica o canto superior esquerdo do texto desenhado.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributos de formatação, como espaçamento de linha e alinhamento, que são aplicados ao texto desenhado.

Exceptions

ArgumentNullException

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

DrawString(Fonte, Fonte, Brush, RectangleF)

Tire a linha de texto especificada no rectangulo especificado com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estrutura que especifica a localização do texto desenhado.

Exceptions

ArgumentNullException

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

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

Tire a linha de texto especificada no rectangulo especificado com os objetos Aspose.Imaging.Brush e Aspose.Imaging.Font especificados usando os atributos de formatação do Aspose.Imaging.StringFormat especificado.

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

Parameters

s string

Cintura para desenhar.

font Font

Aspose.Imaging.Font que define o formato de texto da faixa.

brush Brush

Aspose.Imaging.Brush que determina a cor e a textura do texto desenhado.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estrutura que especifica a localização do texto desenhado.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributos de formatação, como espaçamento de linha e alinhamento, que são aplicados ao texto desenhado.

Exceptions

ArgumentNullException

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

EndUpdate()

Terminar caching das operações gráficas iniciadas depois que BeginUpdate foi chamado. as operações gráficas anteriores serão aplicadas imediatamente ao chamar este método.

public void EndUpdate()

FillClosedCurve(Brush e PointF[])

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.PointF. Este método usa uma tensão padrão de 0,5 e Aspose.Imaging.FillMode.Alternate modo de enchimento.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush e PointF[ ], O FillMode)

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.PointF usando o modo de enchimento especificado.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

fillMode FillMode

Membro da lista de Aspose.Imaging.FillMode que determina como a curva é preenchida.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush e PointF[ ], FillMode , Float)

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.PointF usando o modo de enchimento e tensão especificados.

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

Parameters

brush Brush

Um Aspose.Imaging.Brush que determina as características do enchimento.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que definem a linha.

fillmode FillMode

Membro da lista de Aspose.Imaging.FillMode que determina como a curva é preenchida.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brusque, ponto[])

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.Point. Este método usa uma tensão padrão de 0,5 e Aspose.Imaging.FillMode.Alternate modo de enchimento.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brusque, ponto[ ], O FillMode)

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.Point usando o modo de enchimento especificado.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

fillmode FillMode

Membro da lista de Aspose.Imaging.FillMode que determina como a curva é preenchida.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brusque, ponto[ ], FillMode , Float)

Enche o interior de uma curva de curva cardinal fechada definida por uma série de estruturas Aspose.Imaging.Point usando o modo de enchimento e tensão especificados.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que definem a linha.

fillmode FillMode

Membro da lista de Aspose.Imaging.FillMode que determina como a curva é preenchida.

tension float

Valor maior ou igual a 0,0F que especifica a tensão da curva.

Exceptions

ArgumentNullException

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

FillEllipse(Brusque, RectangleF)

Enche o interior de uma elípsia definida por um rectangulo limitante especificado por uma estrutura Aspose.Imaging.RectangleF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que representa o rectangulo de ligação que define a elípsia.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Flóia, Flóia, Flóia, Flóia)

Enche o interior de uma elípsia definida por um rectangulo limitante especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

x float

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y float

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width float

A largura do rectangulo que define a elípcia.

height float

A altura do rectangulo que define a elípcia.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush e Rectangle)

Enche o interior de uma elípsia definida por um rectangulo limitante especificado por uma estrutura Aspose.Imaging.Rectangle.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que representa o rectangle que define a elípsia.

Exceptions

ArgumentNullException

brush’ is null.

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

Enche o interior de uma elípsia definida por um rectangulo limitante especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

x int

O coordenado x do canto superior esquerdo do rectangulo que define a elípsia.

y int

O y-coordenado do canto superior esquerdo do rectangulo que define a elípsia.

width int

A largura do rectangulo que define a elípcia.

height int

A altura do rectangulo que define a elípcia.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Título: GraphicsPath)

Enche o interior de um Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

path GraphicsPath

Aspose.Imaging.GraphicsPath que representa o caminho para preencher.

Exceptions

ArgumentNullException

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

FillPie(Brush, rectangle, float, float)

Enche o interior de uma peça definida por uma elípsia especificada por uma estrutura Aspose.Imaging.RectangleF e duas linhas radiais.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que representa o rectangle limitante que define a elípsia de que a seção de pé vem.

startAngle float

O ângulo em graus é medido de maneira horária do eixo x até o primeiro lado da seção pie.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para o segundo lado da seção do pie.

Examples

O exemplo a seguir mostra como compilar uma imagem GIF animada de blocos GIF individuais.

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)

Enche o interior de uma peça definida por uma elípsia especificada por uma estrutura Aspose.Imaging.RectangleF e duas linhas radiais.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que representa o rectangulo de limiar que define a elípsia de que a seção de pé vem.

startAngle float

O ângulo em graus é medido de maneira horária do eixo x até o primeiro lado da seção pie.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para o segundo lado da seção do pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Flóia, Flóia, Flóia, Flóia, Flóia)

Enche o interior de uma peça definida por uma elípsia especificada por um par de coordenadas, uma largura, uma altura e duas linhas radiais.

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 as características do enchimento.

x float

O coordenado x do canto superior esquerdo do rectangulo de limiar que define a elípsia de que a seção de pé vem.

y float

O y-coordenado do canto superior esquerdo do rectangulo de ligação que define a elípsia da qual a seção de pé vem.

width float

A largura do rectangulo de limiar que define a elípsia da qual a seção de pé vem.

height float

A altura do rectangulo de limiar que define a elípsia da qual a seção de pé vem.

startAngle float

O ângulo em graus é medido de maneira horária do eixo x até o primeiro lado da seção pie.

sweepAngle float

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para o segundo lado da seção do pie.

Exceptions

ArgumentNullException

brush’ is null.

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

Enche o interior de uma peça definida por uma elípsia especificada por um par de coordenadas, uma largura, uma altura e duas linhas radiais.

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 as características do enchimento.

x int

O coordenado x do canto superior esquerdo do rectangulo de limiar que define a elípsia de que a seção de pé vem.

y int

O y-coordenado do canto superior esquerdo do rectangulo de ligação que define a elípsia da qual a seção de pé vem.

width int

A largura do rectangulo de limiar que define a elípsia da qual a seção de pé vem.

height int

A altura do rectangulo de limiar que define a elípsia da qual a seção de pé vem.

startAngle int

O ângulo em graus é medido de maneira horária do eixo x até o primeiro lado da seção pie.

sweepAngle int

O ângulo em graus é medido de maneira horária do startParâmetro do ângulo para o segundo lado da seção do pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush e PointF[])

Enche o interior de um polígono definido por uma série de pontos especificados pelas estruturas Aspose.Imaging.PointF e Aspose.Imaging.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que representam as vertices do poligon para preencher.

Exceptions

ArgumentNullException

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

FillPolygon(Brush e PointF[ ], O FillMode)

Enche o interior de um poligono definido por uma série de pontos especificados pelas estruturas Aspose.Imaging.PointF usando o modo de enchimento especificado.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points PointF [ ]

Array de Aspose.Imaging.PointF estruturas que representam as vertices do poligon para preencher.

fillMode FillMode

Membro da enumeração Aspose.Imaging.FillMode que determina o estilo do enchimento.

Exceptions

ArgumentNullException

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

FillPolygon(Brusque, ponto[])

Enche o interior de um polígono definido por uma série de pontos especificados por Aspose.Imaging.Point estruturas e Aspose.Imaging.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que representam as vertices do poligon para preencher.

Exceptions

ArgumentNullException

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

FillPolygon(Brusque, ponto[ ], O FillMode)

Enche o interior de um poligono definido por uma série de pontos especificados por Aspose.Imaging.Point estruturas usando o modo de enchimento especificado.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

points Point [ ]

Array de Aspose.Imaging.Point estruturas que representam as vertices do poligon para preencher.

fillMode FillMode

Membro da enumeração Aspose.Imaging.FillMode que determina o estilo do enchimento.

Exceptions

ArgumentNullException

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

FillRectangle(Brush e Rectangle)

Enche o interior de um rectangulo especificado por uma estrutura Aspose.Imaging.Rectangle.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect Rectangle

Aspose.Imaging.Rectangle estrutura que representa o rectangle para preencher.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brusque, RectangleF)

Enche o interior de um rectangulo especificado por uma estrutura Aspose.Imaging.RectangleF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rect RectangleF

Aspose.Imaging.RectangleF estrutura que representa o rectangle para preencher.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Flóia, Flóia, Flóia, Flóia)

Enche o interior de um rectangulo especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

x float

O coordenado x do canto superior esquerdo do rectangulo para preencher.

y float

O y-coordenado do canto superior esquerdo do rectangulo para preencher.

width float

largura do rectangulo para preencher.

height float

altura do rectangulo para preencher.

Exceptions

ArgumentNullException

brush’ is null.

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

Enche o interior de um rectangulo especificado por um par de coordenadas, uma largura e uma altura.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

x int

O coordenado x do canto superior esquerdo do rectangulo para preencher.

y int

O y-coordenado do canto superior esquerdo do rectangulo para preencher.

width int

largura do rectangulo para preencher.

height int

altura do rectangulo para preencher.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush e Rectangle[])

Enche os interiores de uma série de rectangulos especificados por Aspose.Imaging.Rectangle estruturas.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rects Rectangle [ ]

Array de Aspose.Imaging.Rectangle estruturas que representam os rectangles para preencher.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Brusque, RectangleF[])

Enche os interiores de uma série de rectangulos especificados por Aspose.Imaging.RectangleF estruturas.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

rects RectangleF [ ]

Array de Aspose.Imaging.Rectangle estruturas que representam os rectangles para preencher.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Região)

Enche o interior de uma Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush que determina as características do enchimento.

region Region

Aspose.Imaging.Regão que representa a área a preencher.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(Título, Título, Título, Título)

Medir a linha de texto especificada com parâmetros especificados

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

Parameters

text string

O texto para medir.

font Font

Fonte para medir.

layoutArea SizeF

A área do layout.

stringFormat StringFormat

O formato de string.

Returns

SizeF

Tamanho em pixels de string de texto medido

MultiplyTransform(Matrix)

Multiplica o Aspose.Imaging.Matrix que representa a transformação geométrica local deste Aspose.Imaging.Grafica pelo especificado Aspose.Imaging.Matrix, prependendo o especificado Aspose.Imaging.Matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

O Aspose.Imaging.Matrix pelo qual multiplicar a transformação geométrica.

MultiplyTransform(Título: MatrixOrder)

Multiplica o Aspose.Imaging.Matrix que representa a transformação geométrica local deste Aspose.Imaging.Graphics pelo especificado Aspose.Imaging.Matrix na ordem especificada.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

O Aspose.Imaging.Matrix pelo qual multiplicar a transformação geométrica.

order MatrixOrder

Um Aspose.Imaging.MatrixOrder que especifica em que propósito multiplicar as duas matrizes.

ResetTransform()

Resete o Aspose.Imaging.Graphics.Transforma a propriedade para a identidade.

public void ResetTransform()

RotateTransform(Flotação)

Rotará a transformação geométrica local pela quantidade especificada.Este método prevê a rotação à transformação.

public void RotateTransform(float angle)

Parameters

angle float

O ângulo da rotação.

RotateTransform(Armazém, MatrixOrder)

Rotará a transformação geométrica local pela quantidade especificada na ordem especificada.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

O ângulo da rotação.

order MatrixOrder

Um Aspose.Imaging.MatrixOrder que especifica se adicionar ou adicionar a matriz de rotação.

ScaleTransform(Flóia, Flóia)

Escale a transformação geométrica local com as quantidades especificadas.Este método prevê a matriz de escala para a transformação.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

A quantidade pela qual escalar a transformação na direção x-axis.

sy float

A quantidade pela qual escalar a transformação na direção do y-axis.

ScaleTransform(Flutão, Flutão, MatrixOrder)

Escale a transformação geométrica local com as quantidades especificadas na ordem especificada.

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

Parameters

sx float

A quantidade pela qual escalar a transformação na direção x-axis.

sy float

A quantidade pela qual escalar a transformação na direção do y-axis.

order MatrixOrder

Um Aspose.Imaging.MatrixOrder que especifica se adicionar ou adicionar a matriz de escalada.

TranslateTransform(Flóia, Flóia)

Traduz a transformação geométrica local pelas dimensões especificadas.Este método prevê a tradução à transformação.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

O valor da tradução em x.

dy float

O valor da tradução em Y.

TranslateTransform(Flutão, Flutão, MatrixOrder)

Traduz a transformação geométrica local pelas dimensões especificadas na ordem especificada.

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

Parameters

dx float

O valor da tradução em x.

dy float

O valor da tradução em Y.

order MatrixOrder

A ordem (prepend ou append) em que aplicar a tradução.

 Português