Class Brush

Class Brush

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

La classe base del pennello.

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

Ereditarietà

objectDisposableObjectBrush

Derivata

HatchBrush, SolidBrush, TransformBrush

Implementa

IDisposable

Membri ereditati

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

Costruttori

Brush()

protected Brush()

Proprietà

Opacità

Ottiene o imposta l’opacità del pennello. Il valore deve essere compreso tra 0 e 1. Un valore di 0 significa che il pennello è completamente visibile, un valore di 1 significa che il pennello è completamente opaco.

public float Opacity { get; set; }

Valore della Proprietà

float

Esempi

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine. Per dimostrare l’operazione, l’esempio crea una nuova immagine in formato PNG e disegna forme primitive sulla superficie dell’immagine utilizzando i metodi Draw esposti dalla classe Graphics.```csharp [C#]

                                                                                                                                                                                                                                                            //Crea un'istanza di FileStream
                                                                                                                                                                                                                                                            using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                //Crea un'istanza di PngOptions e imposta le sue varie proprietà
                                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                //Imposta la sorgente per PngOptions
                                                                                                                                                                                                                                                                pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                //Crea un'istanza di Image 
                                                                                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Crea e inizializza un'istanza della classe Graphics
                                                                                                                                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                    //Pulisci la superficie di Graphics
                                                                                                                                                                                                                                                                    graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                    //Disegna un arco specificando l'oggetto Pen di colore nero, 
                                                                                                                                                                                                                                                                    //un rettangolo che circonda l'arco, l'angolo di partenza e l'angolo di sweep
                                                                                                                                                                                                                                                                    graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                    //Disegna una Bezier specificando l'oggetto Pen di colore blu e i punti di coordinata.
                                                                                                                                                                                                                                                                    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));

                                                                                                                                                                                                                                                                    //Disegna una curva specificando l'oggetto Pen di colore verde e un array di punti
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Disegna un'ellisse utilizzando l'oggetto Pen e un rettangolo circostante
                                                                                                                                                                                                                                                                    graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                    //Disegna una linea 
                                                                                                                                                                                                                                                                    graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                    //Disegna un segmento di torta
                                                                                                                                                                                                                                                                    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);

                                                                                                                                                                                                                                                                    //Disegna un poligono specificando l'oggetto Pen di colore rosso e un array di punti
                                                                                                                                                                                                                                                                    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) });

                                                                                                                                                                                                                                                                    //Disegna un rettangolo
                                                                                                                                                                                                                                                                    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 oggetto SolidBrush e imposta le sue varie proprietà
                                                                                                                                                                                                                                                                    Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                    brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                    brush.Opacity = 100;

                                                                                                                                                                                                                                                                    //Disegna una stringa utilizzando l'oggetto SolidBrush e il Font, in un punto specifico
                                                                                                                                                                                                                                                                    graphics.DrawString("Questa immagine è creata dall'API Aspose.Imaging", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                    // salva tutte le modifiche.
                                                                                                                                                                                                                                                                    image.Save();
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }

## Metodi

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

Crea un nuovo clone profondo dell'attuale Aspose.Imaging.Brush.

```csharp
public virtual Brush DeepClone()

Restituisce

Brush

Un nuovo Aspose.Imaging.Brush che è il clone profondo di questa istanza di Aspose.Imaging.Brush.

Equals(object)

Controlla se gli oggetti sono uguali.

public override bool Equals(object obj)

Parametri

obj object

L’altro oggetto.

Restituisce

bool

Il risultato del confronto di uguaglianza.

Equals(Brush)

Controlla se gli oggetti sono uguali.

protected bool Equals(Brush other)

Parametri

other Brush

L’altro oggetto.

Restituisce

bool

Il risultato del confronto di uguaglianza.

GetHashCode()

Ottiene il codice hash dell’oggetto corrente.

public override int GetHashCode()

Restituisce

int

Il codice hash.

 Italiano