Class Brush

Class Brush

Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)

A classe base de pincéis.

[JsonObject(MemberSerialization.OptIn)]
public abstract class Brush : DisposableObject, IDisposable

Herança

objectDisposableObjectBrush

Derivados

HatchBrush, SolidBrush, TransformBrush

Implementa

IDisposable

Membros Herdados

DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Construtores

Brush()

protected Brush()

Propriedades

Opacidade

Obtém ou define a opacidade do pincel. O valor deve estar entre 0 e 1. Um valor de 0 significa que o pincel é totalmente visível, um valor de 1 significa que o pincel é totalmente opaco.

public float Opacity { get; set; }

Valor da Propriedade

float

Exemplos

Este exemplo usa a classe Graphics para criar formas primitivas na superfície da Imagem. Para demonstrar a operação, o exemplo cria uma nova Imagem em formato PNG e desenha formas primitivas na superfície da Imagem usando os métodos Draw expostos pela classe Graphics.```csharp [C#]

                                                                                                                                                                                                                                                            //Cria uma instância de FileStream
                                                                                                                                                                                                                                                            using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                //Cria uma instância de PngOptions e define suas várias propriedades
                                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                //Define a Fonte para PngOptions
                                                                                                                                                                                                                                                                pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                //Cria uma instância de Imagem 
                                                                                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Cria e inicializa uma instância da classe Graphics
                                                                                                                                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                    //Limpa a superfície Graphics
                                                                                                                                                                                                                                                                    graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                    //Desenha um Arco especificando o objeto Pen com cor preta, 
                                                                                                                                                                                                                                                                    //um Retângulo envolvendo o Arco, Ângulo de Início e Ângulo de Varredura
                                                                                                                                                                                                                                                                    graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                    //Desenha um Bezier especificando o objeto Pen com cor azul e pontos de coordenadas.
                                                                                                                                                                                                                                                                    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));

                                                                                                                                                                                                                                                                    //Desenha uma Curva especificando o objeto Pen com cor verde e um array de Pontos
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Desenha uma Elipse usando o objeto Pen e um Retângulo envolvente
                                                                                                                                                                                                                                                                    graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                    //Desenha uma Linha 
                                                                                                                                                                                                                                                                    graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                    //Desenha um segmento de Pizza
                                                                                                                                                                                                                                                                    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);

                                                                                                                                                                                                                                                                    //Desenha um Polígono especificando o objeto Pen com cor vermelha e um array de Pontos
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Desenha um Retângulo
                                                                                                                                                                                                                                                                    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)));

                                                                                                                                                                                                                                                                    //Cria um objeto SolidBrush e define suas várias propriedades
                                                                                                                                                                                                                                                                    Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                    brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                    brush.Opacity = 100;

                                                                                                                                                                                                                                                                    //Desenha uma String usando o objeto SolidBrush e Fonte, em um ponto específico
                                                                                                                                                                                                                                                                    graphics.DrawString("Esta imagem é criada pela API Aspose.Imaging", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                    // salva todas as alterações.
                                                                                                                                                                                                                                                                    image.Save();
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }

## Métodos

### <a id="Aspose_Imaging_Brush_DeepClone"></a> DeepClone\(\)

Cria um novo clone profundo do Aspose.Imaging.Brush atual.

```csharp
public virtual Brush DeepClone()

Retorna

Brush

Um novo Aspose.Imaging.Brush que é o clone profundo desta instância de Aspose.Imaging.Brush.

Equals(object)

Verifica se os objetos são iguais.

public override bool Equals(object obj)

Parâmetros

obj object

O outro objeto.

Retorna

bool

O resultado da comparação de igualdade.

Equals(Brush)

Verifica se os objetos são iguais.

protected bool Equals(Brush other)

Parâmetros

other Brush

O outro objeto.

Retorna

bool

O resultado da comparação de igualdade.

GetHashCode()

Obtém o código hash do objeto atual.

public override int GetHashCode()

Retorna

int

O código hash.

 Português