Class Brush

Class Brush

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

La clase base de pinceles.

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

Herencia

objectDisposableObjectBrush

Derivados

HatchBrush, SolidBrush, TransformBrush

Implementa

IDisposable

Miembros heredados

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

Constructores

Brush()

protected Brush()

Propiedades

Opacidad

Obtiene o establece la opacidad del pincel. El valor debe estar entre 0 y 1. Un valor de 0 significa que el pincel es completamente visible, un valor de 1 significa que el pincel es completamente opaco.

public float Opacity { get; set; }

Valor de la Propiedad

float

Ejemplos

Este ejemplo utiliza la clase Graphics para crear formas primitivas en la superficie de la imagen. Para demostrar la operación, el ejemplo crea una nueva imagen en formato PNG y dibuja formas primitivas en la superficie de la imagen utilizando los métodos Draw expuestos por la clase Graphics.```csharp [C#]

                                                                                                                                                                                                                                                            //Crea una instancia de FileStream
                                                                                                                                                                                                                                                            using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                //Crea una instancia de PngOptions y establece sus diversas propiedades
                                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                //Establece la fuente para PngOptions
                                                                                                                                                                                                                                                                pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                //Crea una instancia de Image 
                                                                                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Crea e inicializa una instancia de la clase Graphics
                                                                                                                                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                    //Limpia la superficie de Graphics
                                                                                                                                                                                                                                                                    graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                    //Dibuja un arco especificando el objeto Pen con color negro, 
                                                                                                                                                                                                                                                                    //un rectángulo que rodea el arco, el ángulo de inicio y el ángulo de barrido
                                                                                                                                                                                                                                                                    graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                    //Dibuja un Bezier especificando el objeto Pen con color azul y los puntos de coordenada.
                                                                                                                                                                                                                                                                    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));

                                                                                                                                                                                                                                                                    //Dibuja una curva especificando el objeto Pen con color verde y un array de puntos
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Dibuja una elipse utilizando el objeto Pen y un rectángulo que la rodea
                                                                                                                                                                                                                                                                    graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                    //Dibuja una línea 
                                                                                                                                                                                                                                                                    graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                    //Dibuja un segmento de pastel
                                                                                                                                                                                                                                                                    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);

                                                                                                                                                                                                                                                                    //Dibuja un polígono especificando el objeto Pen con color rojo y un array de puntos
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Dibuja un rectá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)));

                                                                                                                                                                                                                                                                    //Crea un objeto SolidBrush y establece sus diversas propiedades
                                                                                                                                                                                                                                                                    Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                    brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                    brush.Opacity = 100;

                                                                                                                                                                                                                                                                    //Dibuja una cadena utilizando el objeto SolidBrush y la fuente, en un punto específico
                                                                                                                                                                                                                                                                    graphics.DrawString("Esta imagen fue creada por la API Aspose.Imaging", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                    // guarda todos los cambios.
                                                                                                                                                                                                                                                                    image.Save();
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }

## Métodos

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

Crea un nuevo clon profundo del actual Aspose.Imaging.Brush.

```csharp
public virtual Brush DeepClone()

Retorna

Brush

Un nuevo Aspose.Imaging.Brush que es el clon profundo de esta instancia de Aspose.Imaging.Brush.

Equals(object)

Verifica si los objetos son iguales.

public override bool Equals(object obj)

Parámetros

obj object

El otro objeto.

Retorna

bool

El resultado de la comparación de igualdad.

Equals(Brush)

Verifica si los objetos son iguales.

protected bool Equals(Brush other)

Parámetros

other Brush

El otro objeto.

Retorna

bool

El resultado de la comparación de igualdad.

GetHashCode()

Obtiene el código hash del objeto actual.

public override int GetHashCode()

Retorna

int

El código hash.

 Español