Class Brush

Class Brush

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

La classe de base pour les pinceaux.

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

Héritage

objectDisposableObjectBrush

Dérivé

HatchBrush, SolidBrush, TransformBrush

Implémente

IDisposable

Membres hérités

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

Constructeurs

Brush()

protected Brush()

Propriétés

Opacité

Obtient ou définit l’opacité du pinceau. La valeur doit être comprise entre 0 et 1. Une valeur de 0 signifie que le pinceau est entièrement visible, une valeur de 1 signifie que le pinceau est entièrement opaque.

public float Opacity { get; set; }

Valeur de la propriété

float

Exemples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface de l’image. Pour démontrer l’opération, l’exemple crée une nouvelle image au format PNG et dessine des formes primitives sur la surface de l’image à l’aide des méthodes Draw exposées par la classe Graphics.```csharp [C#]

                                                                                                                                                                                                                                                            //Crée une instance de FileStream
                                                                                                                                                                                                                                                            using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                //Crée une instance de PngOptions et définit ses différentes propriétés
                                                                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                //Définit la source pour PngOptions
                                                                                                                                                                                                                                                                pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                //Crée une instance d'image 
                                                                                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Crée et initialise une instance de la classe Graphics
                                                                                                                                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

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

                                                                                                                                                                                                                                                                    //Dessine un arc en spécifiant l'objet Pen ayant une couleur noire, 
                                                                                                                                                                                                                                                                    //un rectangle entourant l'arc, l'angle de départ et l'angle de balayage
                                                                                                                                                                                                                                                                    graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                    //Dessine un Bezier en spécifiant l'objet Pen ayant une couleur bleue et des points de coordonnées.
                                                                                                                                                                                                                                                                    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));

                                                                                                                                                                                                                                                                    //Dessine une courbe en spécifiant l'objet Pen ayant une couleur verte et un tableau de 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) });

                                                                                                                                                                                                                                                                    //Dessine une ellipse en utilisant l'objet Pen et un rectangle environnant
                                                                                                                                                                                                                                                                    graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                    //Dessine une ligne 
                                                                                                                                                                                                                                                                    graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                    //Dessine un segment de tarte
                                                                                                                                                                                                                                                                    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);

                                                                                                                                                                                                                                                                    //Dessine un polygone en spécifiant l'objet Pen ayant une couleur rouge et un tableau de 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) });

                                                                                                                                                                                                                                                                    //Dessine un 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)));

                                                                                                                                                                                                                                                                    //Crée un objet SolidBrush et définit ses différentes propriétés
                                                                                                                                                                                                                                                                    Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                    brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                    brush.Opacity = 100;

                                                                                                                                                                                                                                                                    //Dessine une chaîne en utilisant l'objet SolidBrush et une police, à un point spécifique
                                                                                                                                                                                                                                                                    graphics.DrawString("Cette image est créée par l'API Aspose.Imaging", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                    // Sauvegarde toutes les modifications.
                                                                                                                                                                                                                                                                    image.Save();
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                            }

## Méthodes

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

Crée un nouveau clone profond de l'Aspose.Imaging.Brush actuel.

```csharp
public virtual Brush DeepClone()

Retourne

Brush

Un nouvel Aspose.Imaging.Brush qui est le clone profond de cette instance d’Aspose.Imaging.Brush.

Equals(object)

Vérifie si les objets sont égaux.

public override bool Equals(object obj)

Paramètres

obj object

L’autre objet.

Retourne

bool

Le résultat de la comparaison d’égalité.

Equals(Brush)

Vérifie si les objets sont égaux.

protected bool Equals(Brush other)

Paramètres

other Brush

L’autre objet.

Retourne

bool

Le résultat de la comparaison d’égalité.

GetHashCode()

Obtient le code de hachage de l’objet actuel.

public override int GetHashCode()

Retourne

int

Le code de hachage.

 Français