Class Graphics

Class Graphics

Le nom : Aspose.Imaging Assemblée: Aspose.Imaging.dll (25.4.0)

Il représente les graphiques selon le moteur graphique utilisé dans l’assemblage actuel.

public sealed class Graphics

Inheritance

object Graphics

I membri ereditari

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

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

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

Initialisez une nouvelle instance de la classe Aspose.Imaging.Graphics.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

l’image de source.

Properties

Clip

Obtenez ou définissez la région clipe.

public Region Clip { get; set; }

Valore di proprietà

Region

CompositingQuality

Obtenez ou définissez la qualité de composition.

public CompositingQuality CompositingQuality { get; set; }

Valore di proprietà

CompositingQuality

Dpix

Obtenez la résolution horizontale de ce Aspose.Imaging.Graphics.

public float DpiX { get; }

Valore di proprietà

float

Dpiy

Obtenez la résolution verticale de ce Aspose.Imaging.Graphics.

public float DpiY { get; }

Valore di proprietà

float

Image

Recevoir l’image.

public Image Image { get; }

Valore di proprietà

Image

InterpolationMode

Riceve o impone il modo di interpolazione.

public InterpolationMode InterpolationMode { get; set; }

Valore di proprietà

InterpolationMode

IsInBeginUpdateCall

Obtenez une valeur indiquant si les graphiques sont dans l’état d’appel StartUpdate.

public bool IsInBeginUpdateCall { get; }

Valore di proprietà

bool

PageScale

Obtenez ou définissez l’échelle entre les unités du monde et les Unités de page pour ce Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Valore di proprietà

float

PageUnit

Obtenez ou définissez l’unité de mesure utilisée pour les coordonnées de page dans ce Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Valore di proprietà

GraphicsUnit

PaintableImageOptions

Obtenez ou définissez les options d’image, utilisées pour créer des images de vacteur peintes à dessiner.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valore di proprietà

ImageOptionsBase

SmoothingMode

Ottenere o impostare il modo di scivolare.

public SmoothingMode SmoothingMode { get; set; }

Valore di proprietà

SmoothingMode

TextRenderingHint

Riceve o mette il testo rendering indice.

public TextRenderingHint TextRenderingHint { get; set; }

Valore di proprietà

TextRenderingHint

Transform

Obtenez ou mettez une copie de la transformation du monde géométrique pour ce Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Valore di proprietà

Matrix

Methods

BeginUpdate()

Les effets graphiques appliqués ultérieurement ne seront pas appliqués immédiatement au lieu de l’EndUpdate provoquera l’application de tous les effets à la fois.

public void BeginUpdate()

Remarks

Remarquez que les effets après le début de l’appel ne seront pas appliqués si le début de l’appel n’est pas appelé.

Clear(Color)

Nettoyez la surface graphique en utilisant la couleur spécifiée.

public void Clear(Color color)

Parameters

color Color

La couleur pour nettoyer la surface graphique par.

Examples

Ces exemples utilisent la classe GraphicsPath et les graphiques pour créer et manipuler les Figures sur une surface d’image. Exemple crée une nouvelle image (de type Tiff), nettoie la surface et attire les chemins à l’aide de la classes GraphiquePate.

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

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Pén, fleet, fleet, fleet, fleet, fleet, fleet)

Un arc représente une portion d’une ellipse spécifiée par un couple de coordonnées, une largeur et une hauteur.

public void DrawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’arc.

x float

Le coordonné x du coin supérieur gauche du rectangle qui définit l’éllipse.

y float

La coordonnée y du coin supérieur gauche du rectangle qui définit l’éllipse.

width float

La largeur du rectangle qui définit l’éllipse.

height float

L’altitude du rectangle qui définit l’éllipse.

startAngle float

Angle en degrés mesuré à l’horloge de l’axe x au point de départ de l’arc.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ pour terminer le point de l’arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pén, RectangleF, float, float)

Trace un arc représentant une portion d’une ellipse spécifiée par une structure Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’arc.

rect RectangleF

Aspose.Imaging.RectangleF structure qui définit les limites de l’éllipse.

startAngle float

Angle en degrés mesuré à l’horloge de l’axe x au point de départ de l’arc.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ pour terminer le point de l’arc.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pén, int, int, int, int, int, int)

Un arc représente une portion d’une ellipse spécifiée par un couple de coordonnées, une largeur et une hauteur.

public void DrawArc(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’arc.

x int

Le coordonné x du coin supérieur gauche du rectangle qui définit l’éllipse.

y int

La coordonnée y du coin supérieur gauche du rectangle qui définit l’éllipse.

width int

La largeur du rectangle qui définit l’éllipse.

height int

L’altitude du rectangle qui définit l’éllipse.

startAngle int

Angle en degrés mesuré à l’horloge de l’axe x au point de départ de l’arc.

sweepAngle int

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ pour terminer le point de l’arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pén, rectangle, float, float)

Trace un arc représentant une portion d’une ellipse spécifiée par une structure Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’arc.

rect Rectangle

Aspose.Imaging.RectangleF structure qui définit les limites de l’éllipse.

startAngle float

Angle en degrés mesuré à l’horloge de l’axe x au point de départ de l’arc.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ pour terminer le point de l’arc.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Pén, flotte, flotte, flotte, flotte, flotte, flotte, flotte, flotte, flotte)

Il dessine une ligne Bézier définie par quatre paires ordonnées de coordonnées représentant des points.

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 qui détermine la couleur, la largeur et le style de la courbe.

x1 float

Le coordonné x du point de départ de la courbe.

y1 float

La coordonnée y du point de départ de la courbe.

x2 float

Le coordonné x du premier point de contrôle de la courbe.

y2 float

La coordonnée y du premier point de contrôle de la courbe.

x3 float

Le coordonné x du second point de contrôle de la courbe.

y3 float

La coordonnée y du deuxième point de contrôle de la courbe.

x4 float

La coordonnée x du point de fin de la courbe.

y4 float

La coordonnée y du point de fin de la courbe.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(PointF, PointF, PointF et PointF)

Il dessine une spline Bézier définie par quatre structures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la courbe.

pt1 PointF

Aspose.Imaging.PointF structure qui représente le point de départ de la courbe.

pt2 PointF

Aspose.Imaging.PointF structure qui représente le premier point de contrôle de la courbe.

pt3 PointF

Aspose.Imaging.PointF structure qui représente le deuxième point de contrôle de la courbe.

pt4 PointF

Aspose.Imaging.PointF structure qui représente le point de fin de la courbe.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Point, point, point, point et point)

Il dessine une spline Bézier définie par quatre structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen structure qui détermine la couleur, la largeur et le style de la courbe.

pt1 Point

Aspose.Imaging.Structure du point qui représente le point de départ de la courbe.

pt2 Point

Aspose.Imaging.Structure du point qui représente le premier point de contrôle de la courbe.

pt3 Point

Aspose.Imaging.Structure du point qui représente le deuxième point de contrôle de la courbe.

pt4 Point

Aspose.Imaging.Structure du point qui représente le point de fin de la courbe.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Le point, point[])

Entraîne une série de splines de Bézier à partir d’une gamme de structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la courbe.

points Point [ ]

Régime de structures Aspose.Imaging.point qui représentent les points qui déterminent la courbe.

Exceptions

ArgumentNullException

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

DrawBeziers(Pén, PointF[])

Entraîne une série de splines de Bézier à partir d’une gamme de structures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la courbe.

points PointF [ ]

Un ensemble de structures Aspose.Imaging.PointF qui représentent les points qui déterminent la courbe.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pén, PointF[])

Il dessine une spline cardinale fermée définie par une série de structures Aspose.Imaging.PointF. Cette méthode utilise une tension par défaut de 0.5 et W L17.FillMode.Alternate mode de remplissement.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pén, PointF[ ], La flotte)

Trace une spline cardinale fermée définie par une série de structures Aspose.Imaging.PointF en utilisant une tension spécifiée.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Le point, point[])

Trace une spline cardinale fermée définie par une série de structures Aspose.Imaging.Point.Cette méthode utilise une tension par défaut de 0.5 et W L17.FillMode.Alternate mode de remplissement.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Le point, point[ ], La flotte)

Trace une spline cardinale fermée définie par un certain nombre de structures Aspose.Imaging.Point en utilisant une tension spécifiée.Cette méthode utilise un mode de remplissage par défaut __FillMode.Alternate.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawCurve(Pén, PointF[])

Trace une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.PointF. Cette méthode utilise une tension par défaut de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

Exceptions

ArgumentNullException

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

DrawCurve(Pén, PointF[ ], La flotte)

Trace une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.PointF en utilisant une tension déterminée.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Un ensemble de structures Aspose.Imaging.PointF qui représentent les points qui définissent la courbe.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawCurve(Pén, PointF[ ], et int, int)

Il dessine une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.PointF. Le dessin commence à partir du début de la série.Cette méthode utilise une tension par défaut de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

offset int

Offset du premier élément dans l’ordre du paramètre points" vers le point de départ dans la courbe.

numberOfSegments int

Nombre de segments après le point de départ à inclure dans la courbe.

Exceptions

ArgumentNullException

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

DrawCurve(Pén, PointF[ ], int , int , float)

Trace une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.PointF en utilisant une tension déterminée.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

offset int

Offset du premier élément dans l’ordre du paramètre points" vers le point de départ dans la courbe.

numberOfSegments int

Nombre de segments après le point de départ à inclure dans la courbe.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawCurve(Le point, point[])

Trace une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Le point, point[ ], La flotte)

Traîne une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.Point en utilisant une tension déterminée.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawCurve(Le point, point[ ], int , int , float)

Traîne une spline cardinale à travers une série spécifiée de structures Aspose.Imaging.Point en utilisant une tension déterminée.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et la hauteur de la courbe.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

offset int

Offset du premier élément dans l’ordre du paramètre points" vers le point de départ dans la courbe.

numberOfSegments int

Nombre de segments après le point de départ à inclure dans la courbe.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

DrawEllipse(Pén, RectangleF)

Enregistre une éllipse définie par un boîtier Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’éllipse.

rect RectangleF

Aspose.Imaging.RectangleF structure qui définit les limites de l’éllipse.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pén, flot, flot, flot, flot)

Un éllipse est défini par un rectangle limitant spécifié par un couple de coordonnées, une hauteur et une largeur.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’éllipse.

x float

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

y float

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

width float

La largeur du rectangle limitant qui définit l’éllipse.

height float

L’altitude du rectangle de bord qui définit l’éllipse.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pén, rectangle)

Trace une éllipse spécifiée par une structure limitante Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’éllipse.

rect Rectangle

WL17_.Structure rectangle qui définit les limites de l’éllipse.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Pén, int, int, int, int)

Un éllipse est défini par un rectangle limitant spécifié par un couple de coordonnées, une hauteur et une largeur.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de l’éllipse.

x int

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

y int

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

width int

La largeur du rectangle limitant qui définit l’éllipse.

height int

L’altitude du rectangle de bord qui définit l’éllipse.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Étiquette : PointF)

Tirez le Aspose.Imaging.Graphics.Image spécifié, en utilisant sa taille physique initiale, à l’emplacement indiqué.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

L’image à tirer avec.

point PointF

Aspose.Imaging.PointF structure qui représente le coin supérieur gauche de l’image dessinée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Images, flottes et flottes)

Tirez le Aspose.Imaging.Graphics.Image spécifié, en utilisant sa taille physique initiale, à l’emplacement indiqué.

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

Parameters

sourceImage Image

L’image à tirer avec.

x float

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y float

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Étiquette, RectangleF)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

L’image à tirer avec.

rect RectangleF

Aspose.Imaging.RectangleF structure qui spécifie la localisation et la taille de l’image tirée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, Rectangle, GraphicsUnit)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectDestination Rectangle

Le rectangle de destination.

graphicsUnit GraphicsUnit

l’unité graphique.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, RectangleF, GraphicsUnit)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectDestination RectangleF

Le rectangle de destination.

graphicsUnit GraphicsUnit

l’unité graphique.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, Rectangle, GraphicsUnit, ImageAttributes)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectDestination Rectangle

Le rectangle de destination.

graphicsUnit GraphicsUnit

l’unité graphique.

imageAttributes ImageAttributes

Les attributs de l’image.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, RectangleF, GraphicsUnit, ImageAttributes)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectDestination RectangleF

Le rectangle de destination à tirer.

graphicsUnit GraphicsUnit

l’unité graphique.

imageAttributes ImageAttributes

Les attributs de l’image.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, Rectangle, Rectangle, GraphicsUnit)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectSource Rectangle

La source rectale.

rectDestination Rectangle

Destination de droite.

graphicsUnit GraphicsUnit

l’unité graphique.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, RectangleF, RectangleF, GraphicsUnit)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectSource RectangleF

La source rectale.

rectDestination RectangleF

Destination de droite.

graphicsUnit GraphicsUnit

l’unité graphique.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectSource Rectangle

La source rectale.

rectDestination Rectangle

Destination de droite.

graphicsUnit GraphicsUnit

l’unité graphique.

imageAttributes ImageAttributes

Les attributs de l’image.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

rectSource RectangleF

Le rectangle source.

rectDestination RectangleF

Le rectangle de destination.

graphicsUnit GraphicsUnit

l’unité graphique à utiliser.

imageAttributes ImageAttributes

L’image permet d’être utilisée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(image, point[])

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

DrawImage(image, point[ ], Le rectangle)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect Rectangle

Le rectangle source.

DrawImage(image, point[ ], Rectangle, GraphicsUnit)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect Rectangle

Le rectangle source.

srcUnit GraphicsUnit

Les unités de mesure.

DrawImage(image, point[ ], Rectangle, GraphicsUnit, ImageAttributes)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect Rectangle

Le rectangle source.

srcUnit GraphicsUnit

Les unités de mesure.

imageAttributes ImageAttributes

Les attributs de l’image.

DrawImage(Étiquette : PointF[])

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

Exceptions

ArgumentNullException

image

DrawImage(Étiquette : PointF[ ], Le RectangleF)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect RectangleF

Le rectangle source.

DrawImage(Étiquette : PointF[ ], RectangleF, GraphicsUnit)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect RectangleF

Le rectangle source.

srcUnit GraphicsUnit

Les unités de mesure.

DrawImage(Étiquette : PointF[ ], RectangleF, GraphicsUnit, ImageAttributes)

Tire la portion spécifiée de l’image spécifiée ’ à l’emplacement spécifié et avec la taille spécifiée.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Un ensemble de trois structures PointF qui définissent un parallélogramme.

srcRect RectangleF

Le rectangle source.

srcUnit GraphicsUnit

Les unités de mesure.

imageAttributes ImageAttributes

Les attributs de l’image.

DrawImage(Image, flottes, flottes, flottes)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

x float

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y float

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

width float

L’ampleur de l’image tirée.

height float

La hauteur de l’image tirée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(image, point)

Tirez le Aspose.Imaging.Graphics.Image spécifié, en utilisant sa taille physique initiale, à l’emplacement indiqué.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

L’image à tirer avec.

point Point

Aspose.Imaging.Structure de point qui représente l’emplacement du coin supérieur à gauche de l’image tirée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Images int, int, int)

Trace l’image spécifiée, en utilisant sa taille physique originale, à l’emplacement spécifié par un couple de coordonnées.

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

Parameters

sourceImage Image

L’image à tirer avec.

x int

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y int

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Critique, Rectangle)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’image à tirer avec.

rect Rectangle

Aspose.Imaging.Structure rectangle qui spécifie l’emplacement et la taille de l’image tirée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Image, int, int, int, int)

Tirez le Aspose.Imaging.Graphics.Image spécifié à l’emplacement et avec la taille déterminée.

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

Parameters

sourceImage Image

L’image à tirer avec.

x int

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y int

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

width int

L’ampleur de l’image tirée.

height int

La hauteur de l’image tirée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(image, point)

Trace une image spécifiée en utilisant sa taille physique originale à un endroit spécifié.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

L’image à tirer avec.

point Point

Aspose.Imaging.Structure de point qui spécifie le coin supérieur gauche de l’image dessinée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Images int, int, int)

Trace l’image spécifiée en utilisant sa taille physique originale à l’emplacement spécifié par un couple de coordonnées.

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

Parameters

sourceImage Image

L’image à tirer avec.

x int

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y int

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Critique, Rectangle)

Trace une image spécifiée en utilisant sa taille physique originale à un endroit spécifié.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’image à tirer avec.

rect Rectangle

Aspose.Imaging.Rectangle qui spécifie le coin supérieur à gauche de l’image tirée.Les propriétés X et Y du rectangre précisent le angle supérieure à droite.La largeur et la hauteur sont ignorées.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Image, int, int, int, int)

Trace une image spécifiée en utilisant sa taille physique originale à un endroit spécifié.

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

Parameters

sourceImage Image

L’image à tirer avec.

x int

Le coordonné x de l’angle supérieur gauche de l’image dessinée.

y int

La coordonnée y de l’angle supérieur gauche de l’image dessinée.

width int

Le paramètre n’est pas utilisé.

height int

Le paramètre n’est pas utilisé.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Critique, Rectangle)

Trace l’image spécifiée sans échelon et la clipe, si nécessaire, pour s’adapter au rectangle spécifié.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’image à tirer avec.

rect Rectangle

Le Aspose.Imaging.Rectangle dans lequel dessiner l’image.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Point, point et point)

Entraîne une ligne reliant deux structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la ligne.

point1 Point

Aspose.Imaging.Structure du point qui représente le premier point à se connecter.

point2 Point

Aspose.Imaging.Structure du point qui représente le deuxième point pour se connecter.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

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

Enregistre une ligne qui connecte deux structures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la ligne.

point1 PointF

Aspose.Imaging.PointF structure qui représente le premier point à se connecter.

point2 PointF

Aspose.Imaging.PointF structure qui représente le deuxième point pour se connecter.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pén, int, int, int, int)

Il trace une ligne reliant les deux points spécifiés par les paires de coordonnées.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la ligne.

x1 int

Le coordonné x du premier point.

y1 int

la coordonnée du premier point.

x2 int

Le coordonné x du second point.

y2 int

la coordonnée du second point.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pén, flot, flot, flot, flot)

Il trace une ligne reliant les deux points spécifiés par les paires de coordonnées.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la ligne.

x1 float

Le coordonné x du premier point.

y1 float

la coordonnée du premier point.

x2 float

Le coordonné x du second point.

y2 float

la coordonnée du second point.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Le point, point[])

Il dessine une série de segments de ligne qui relient un certain nombre de structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style des segments de ligne.

points Point [ ]

Résumé de structures Aspose.Imaging.point qui représentent les points à connecter.

Exceptions

ArgumentNullException

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

ArgumentException

La gamme de points contient moins de 2 points.

DrawLines(Pén, PointF[])

Il dessine une série de segments de ligne qui relient un certain nombre de structures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style des segments de ligne.

points PointF [ ]

Un ensemble de structures Aspose.Imaging.PointF qui représentent les points à connecter.

Exceptions

ArgumentNullException

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

ArgumentException

La gamme de points contient moins de 2 points.

DrawPath(Pén, GraphicsPath)

Envoyez un Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du chemin.

path GraphicsPath

Aspose.Imaging.GraphicsPath pour dessiner.

Examples

Ces exemples utilisent la classe GraphicsPath et les graphiques pour créer et manipuler les Figures sur une surface d’image. Exemple crée une nouvelle image (de type Tiff), nettoie la surface et attire les chemins à l’aide de la classes GraphiquePate.

//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(Pén, RectangleF, float, float)

Il dessine une forme de pie définie par un ellipse spécifié par une structure Aspose.Imaging.RectangleF et deux lignes radiales.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la forme du pie.

rect RectangleF

Aspose.Imaging.RectangleF structure qui représente la rectangule limitante qui définit l’éllipse d’où vient la forme de la pierre.

startAngle float

Angle mesurée en degrés d’horloge de l’axe x au premier côté de la forme de la pièce.

sweepAngle float

Angle mesuré en degrés de façon horloge depuis le paramètre startAngle’ à l’autre côté de la forme de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pén, fleet, fleet, fleet, fleet, fleet, fleet)

Il s’agit d’une forme de pieds définie par une ellipse spécifiée par un couple de coordonnées, une largeur, une hauteur et deux lignes radiales.

public void DrawPie(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la forme du pie.

x float

Le coordonné x de l’angle supérieur gauche du rectangle de liaison qui définit l’éllipse de laquelle vient la forme de la pierre.

y float

La coordonnée y de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse d’où vient la forme de la pierre.

width float

La largeur du rectangle limitant qui définit l’éllipse de laquelle vient la forme de la pierre.

height float

L’altitude du rectangle limitant qui définit l’éllipse d’où vient la forme de la pierre.

startAngle float

Angle mesurée en degrés d’horloge de l’axe x au premier côté de la forme de la pièce.

sweepAngle float

Angle mesuré en degrés de façon horloge depuis le paramètre startAngle’ à l’autre côté de la forme de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pén, rectangle, float, float)

Trace une forme de pie définie par un éllipse spécifié par une structure Aspose.Imaging.Rectangle et deux lignes radiales.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la forme du pie.

rect Rectangle

Aspose.Imaging.Structure de rectangle qui représente la réctange limitante qui définit l’éllipse d’où vient la forme de la pierre.

startAngle float

Angle mesurée en degrés d’horloge de l’axe x au premier côté de la forme de la pièce.

sweepAngle float

Angle mesuré en degrés de façon horloge depuis le paramètre startAngle’ à l’autre côté de la forme de pie.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(Pén, int, int, int, int, int, int)

Il s’agit d’une forme de pieds définie par une ellipse spécifiée par un couple de coordonnées, une largeur, une hauteur et deux lignes radiales.

public void DrawPie(Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style de la forme du pie.

x int

Le coordonné x de l’angle supérieur gauche du rectangle de liaison qui définit l’éllipse de laquelle vient la forme de la pierre.

y int

La coordonnée y de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse d’où vient la forme de la pierre.

width int

La largeur du rectangle limitant qui définit l’éllipse de laquelle vient la forme de la pierre.

height int

L’altitude du rectangle limitant qui définit l’éllipse d’où vient la forme de la pierre.

startAngle int

Angle mesurée en degrés d’horloge de l’axe x au premier côté de la forme de la pièce.

sweepAngle int

Angle mesuré en degrés de façon horloge depuis le paramètre startAngle’ à l’autre côté de la forme de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pén, PointF[])

Il dessine un polygone défini par une série de structures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du polygone.

points PointF [ ]

Le nombre de structures Aspose.Imaging.PointF qui représentent les vertices du polygone.

Exceptions

ArgumentNullException

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

DrawPolygon(Le point, point[])

Il dessine un polygone défini par une série de structures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du polygone.

points Point [ ]

Régime de Aspose.Imaging.Structures de point représentant les vertices du polygone.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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én, RectangleF)

Trace un rectangle spécifié par une structure Aspose.Imaging.RectanglesF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du rectangle.

rect RectangleF

Une structure Aspose.Imaging.RectangleF qui représente le rectange à dessiner.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, rectangle)

Trace un rectangle spécifié par une structure Aspose.Imaging.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du rectangle.

rect Rectangle

Une structure Aspose.Imaging.Rectangle qui représente le rectange à dessiner.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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én, flot, flot, flot, flot)

Un rectangle spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du rectangle.

x float

Le coordonné x de l’angle supérieur gauche du rectangle à dessiner.

y float

La coordonnée y de l’angle supérieur gauche du rectangle à tirer.

width float

La largeur du rectangle à dessiner.

height float

La hauteur du rectangle à dessiner.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, int, int, int, int)

Un rectangle spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style du rectangle.

x int

Le coordonné x de l’angle supérieur gauche du rectangle à dessiner.

y int

La coordonnée y de l’angle supérieur gauche du rectangle à tirer.

width int

La largeur du rectangle à dessiner.

height int

La hauteur du rectangle à dessiner.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pén, RectangleF[])

Il dessine une série de rectangles spécifiées par les structures Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style des outils des rectangles.

rects RectangleF [ ]

Résumé de structures Aspose.Imaging.RectangleF qui représentent les rectangles à dessiner.

Exceptions

ArgumentNullException

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

DrawRectangles(Pén, rectangle[])

Trace une série de rectangles spécifiées par Aspose.Imaging.Rectangle structures.

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

Parameters

pen Pen

Aspose.Imaging.Pen qui détermine la couleur, la largeur et le style des outils des rectangles.

rects Rectangle [ ]

Réseau de structures Aspose.Imaging.Rectangle qui représentent les rectangles à dessiner.

Examples

Cet exemple montre la création et l’utilisation des objets de Pen. L’exemple crée une nouvelle image et dessine des rectangles sur la surface de l’image.

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

Tirez la ligne de texte spécifiée à l’emplacement spécificé avec les objets Aspose.Imaging.Brush et W L17.Font.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

x float

Le coordonné x du coin supérieur gauche du texte tiré.

y float

La coordonnée y de l’angle supérieur gauche du texte tiré.

Exceptions

ArgumentNullException

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

DrawString(Télécharger, Brush, PointF)

Tirez la ligne de texte spécifiée à l’emplacement spécificé avec les objets Aspose.Imaging.Brush et W L17.Font.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

point PointF

Aspose.Imaging.PointF structure qui spécifie l’angle supérieur gauche du texte tiré.

Examples

Cet exemple utilise la classe Graphics pour créer des formes primitives sur la surface d’image. Pour démontrer l’opération, l’exemple crée une nouvelle image dans le format PNG et dessine les formes primaires sur cette surface en utilisant les méthodes de dessin exposées par la catégorie Graphiques.

//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(string, Font, Brush, float, float, StringFormat)

Tirez la ligne de texte spécifiée à l’emplacement indiqué avec le Aspose.Imaging.Brush et les objets fonciers spécificés en utilisant les attributs de formatisation du __ WL15_.StringFormat.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

x float

Le coordonné x du coin supérieur gauche du texte tiré.

y float

La coordonnée y de l’angle supérieur gauche du texte tiré.

format StringFormat

Aspose.Imaging.StringFormat qui spécifie les attributs de formatage, tels que l’espace de ligne et l’alignement, qui sont appliqués au texte dessiné.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, PointF, StringFormat)

Tirez la ligne de texte spécifiée à l’emplacement indiqué avec le Aspose.Imaging.Brush et les objets fonciers spécificés en utilisant les attributs de formatisation du __ WL15_.StringFormat.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

point PointF

Aspose.Imaging.PointF structure qui spécifie l’angle supérieur gauche du texte tiré.

format StringFormat

Aspose.Imaging.StringFormat qui spécifie les attributs de formatage, tels que l’espace de ligne et l’alignement, qui sont appliqués au texte dessiné.

Exceptions

ArgumentNullException

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

DrawString(Fontaine, Fontaine, Brush, RectangleF)

Tirez la ligne de texte spécifiée dans le rectangle indiqué avec les objets Aspose.Imaging.Brush et __ WL16__ .Font spécificés.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structure qui spécifie l’emplacement du texte tiré.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, RectangleF, StringFormat)

Tirez la ligne de texte spécifiée dans le rectangle défini avec les objets Aspose.Imaging.Brux et Wl17.Font en utilisant les attributs de formatage de l’indicatif __ WL 17__ .StringFormat.

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

Parameters

s string

Le drapeau à dessiner.

font Font

Aspose.Imaging.Fonte qui définit le format de texte de la barre.

brush Brush

Aspose.Imaging.Brush qui détermine la couleur et la texture du texte tiré.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structure qui spécifie l’emplacement du texte tiré.

format StringFormat

Aspose.Imaging.StringFormat qui spécifie les attributs de formatage, tels que l’espace de ligne et l’alignement, qui sont appliqués au texte dessiné.

Exceptions

ArgumentNullException

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

EndUpdate()

Terminer la cache des opérations graphiques commencé après le début de l’appel. Les opérations graphiques précédentes seront appliquées à la fois lors de l’appel de cette méthode.

public void EndUpdate()

FillClosedCurve(Brush et PointF[])

Il remplit l’intérieur d’une courbe de cardinale fermée définie par une série de structures Aspose.Imaging.PointF. Cette méthode utilise une tension par défaut de 0.5 et W L17.FillMode.Alternate mode.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush et PointF[ ], Le FillMode)

Il remplit l’intérieur d’une courbe cardinale fermée définie par une série de structures Aspose.Imaging.PointF en utilisant le mode de rempli spécifié.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

fillMode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine la façon dont la courbe est remplie.

Exceptions

ArgumentNullException

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

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

Il remplit l’intérieur d’une courbe de coudée cardinale fermée définie par une série de structures Aspose.Imaging.PointF en utilisant le mode de chargement et la tension spécifiées.

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

Parameters

brush Brush

Un Aspose.Imaging.Brush qui détermine les caractéristiques du remplissage.

points PointF [ ]

Résumé des structures Aspose.Imaging.PointF qui définissent la spline.

fillmode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine la façon dont la courbe est remplie.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

FillClosedCurve(Le point, point[])

Il remplit l’intérieur d’une courbe de cordon fermé définie par une série de structures Aspose.Imaging.Point.Cette méthode utilise une tension par défaut de 0.5 et W L17.FillMode.Alternate mode.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Le point, point[ ], Le FillMode)

Il remplit l’intérieur d’une courbe de cordon fermé définie par une série de structures Aspose.Imaging.Point en utilisant le mode de rempli spécifié. Cette méthode utilise une tension par défaut de 0.5.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

fillmode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine la façon dont la courbe est remplie.

Exceptions

ArgumentNullException

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

FillClosedCurve(Le point, point[ ], FillMode, Float)

Il remplit l’intérieur d’une courbe de coudée cardinale fermée définie par une série de structures Aspose.Imaging.Point en utilisant le mode de rempli spécifié et la tension.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points Point [ ]

Résumé des structures Aspose.Imaging.point qui définissent la spline.

fillmode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine la façon dont la courbe est remplie.

tension float

Valeur supérieure ou égale à 0.0F qui spécifie la tension de la courbe.

Exceptions

ArgumentNullException

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

FillEllipse(Brush, RectangleF)

Il remplit l’intérieur d’une ellipse définie par un rectangle de bord spécifié par une structure Aspose.Imaging.RectanglesF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect RectangleF

Aspose.Imaging.RectangleF structure qui représente la rectangule limitante qui définit l’éllipse.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Feuillot, Feuillot, Feuillot)

Il remplit l’intérieur d’une ellipse définie par un rectangle de bord spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x float

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

y float

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

width float

La largeur du rectangle limitant qui définit l’éllipse.

height float

L’altitude du rectangle de bord qui définit l’éllipse.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush et rectangle)

Il remplit l’intérieur d’une ellipse définie par un rectangle de bord spécifié par une structure Aspose.Imaging.Rectangles.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect Rectangle

Aspose.Imaging.Structure de rectangle qui représente la réctange limitante qui définit l’éllipse.

Exceptions

ArgumentNullException

brush’ is null.

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

Il remplit l’intérieur d’une ellipse définie par un rectangle de bord spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x int

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

y int

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse.

width int

La largeur du rectangle limitant qui définit l’éllipse.

height int

L’altitude du rectangle de bord qui définit l’éllipse.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Brush et GraphicsPath)

Il remplit l’intérieur d’un Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

path GraphicsPath

Aspose.Imaging.GraphicsPath qui représente le chemin à remplir.

Exceptions

ArgumentNullException

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

FillPie(Brush, rectangle, flot, flot)

Il remplit l’intérieur d’une section de pie définie par un éllipse spécifié par une structure Aspose.Imaging.RectangleF et deux lignes radiales.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect Rectangle

Aspose.Imaging.Structure de rectangle qui représente la réctange limitante qui définit l’éllipse de laquelle vient la section pie.

startAngle float

Angle en degrés mesurés à l’horloge de l’axe x au premier côté de la section pie.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ à l’autre côté de la section pie.

Examples

L’exemple ci-dessous montre comment composer une image GIF animée à partir de blocs individuels Gif.

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)

Il remplit l’intérieur d’une section de pie définie par un éllipse spécifié par une structure Aspose.Imaging.RectangleF et deux lignes radiales.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect RectangleF

Aspose.Imaging.RectangleF structure qui représente la rectangule limitante qui définit l’éllipse de laquelle vient la section pie.

startAngle float

Angle en degrés mesurés à l’horloge de l’axe x au premier côté de la section pie.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ à l’autre côté de la section pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Flate, flate, flate, flate, flate, flate, flate)

Il remplit l’intérieur d’une section de pie définie par un éllipse spécifié par un couple de coordonnées, une largeur, une hauteur et deux lignes radiales.

public void FillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x float

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

y float

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

width float

La largeur du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

height float

L’altitude du rectangle de bord qui définit l’éllipse de laquelle vient la section pie.

startAngle float

Angle en degrés mesurés à l’horloge de l’axe x au premier côté de la section pie.

sweepAngle float

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ à l’autre côté de la section pie.

Exceptions

ArgumentNullException

brush’ is null.

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

Il remplit l’intérieur d’une section de pie définie par un éllipse spécifié par un couple de coordonnées, une largeur, une hauteur et deux lignes radiales.

public void FillPie(Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x int

Le coordonné x de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

y int

Le y-coordinate de l’angle supérieur gauche du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

width int

La largeur du rectangle limitant qui définit l’éllipse de laquelle vient la section pie.

height int

L’altitude du rectangle de bord qui définit l’éllipse de laquelle vient la section pie.

startAngle int

Angle en degrés mesurés à l’horloge de l’axe x au premier côté de la section pie.

sweepAngle int

Angle en degrés mesuré à l’horloge depuis le paramètre startAngle’ à l’autre côté de la section pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush et PointF[])

Il remplit l’intérieur d’un polygone défini par une gamme de points spécifiés par les structures Aspose.Imaging.PointF et W L17.FillMode.Alternate.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points PointF [ ]

Un ensemble de structures Aspose.Imaging.PointF qui représentent les vertices du polygone à remplir.

Exceptions

ArgumentNullException

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

FillPolygon(Brush et PointF[ ], Le FillMode)

Il remplit l’intérieur d’un polygone défini par une gamme de points spécifiés par les structures Aspose.Imaging.PointF en utilisant le mode de rempli précisé.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points PointF [ ]

Un ensemble de structures Aspose.Imaging.PointF qui représentent les vertices du polygone à remplir.

fillMode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine le style du remplissage.

Exceptions

ArgumentNullException

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

FillPolygon(Le point, point[])

Il remplit l’intérieur d’un polygone défini par une gamme de points spécifiés par les structures de point Aspose.Imaging.point et __ WL16__ .FillMode.Alternate.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points Point [ ]

Résumé de structures Aspose.Imaging.point qui représentent les vertices du polygone à remplir.

Exceptions

ArgumentNullException

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

FillPolygon(Le point, point[ ], Le FillMode)

Il remplit l’intérieur d’un polygone défini par une gamme de points spécifiés par Aspose.Imaging.Structures de point en utilisant le mode de rempli précisé.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

points Point [ ]

Résumé de structures Aspose.Imaging.point qui représentent les vertices du polygone à remplir.

fillMode FillMode

Membre de la liste Aspose.Imaging.FillMode qui détermine le style du remplissage.

Exceptions

ArgumentNullException

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

FillRectangle(Brush et rectangle)

Il remplit l’intérieur d’un rectangle spécifié par une structure Aspose.Imaging.Rectangles.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect Rectangle

Aspose.Imaging.Structure de rectangle qui représente le droit à remplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, RectangleF)

Il remplit l’intérieur d’un rectangle spécifié par une structure Aspose.Imaging.RectanglesF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rect RectangleF

Aspose.Imaging.RectangleF structure qui représente le rectange à remplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Feuillot, Feuillot, Feuillot)

Il remplit l’intérieur d’un rectangle spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x float

La coordonnée x du coin supérieur gauche du rectangle à remplir.

y float

La coordonnée y du coin supérieur gauche du rectangle à remplir.

width float

La largeur du rectangle à remplir.

height float

La hauteur du rectangle à remplir.

Exceptions

ArgumentNullException

brush’ is null.

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

Il remplit l’intérieur d’un rectangle spécifié par un couple de coordonnées, une largeur et une hauteur.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

x int

La coordonnée x du coin supérieur gauche du rectangle à remplir.

y int

La coordonnée y du coin supérieur gauche du rectangle à remplir.

width int

La largeur du rectangle à remplir.

height int

La hauteur du rectangle à remplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush et rectangle[])

Il remplit les intérieurs d’une série de rectangles spécifiées par Aspose.Imaging.Rectangle structures.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rects Rectangle [ ]

Le nombre de structures Aspose.Imaging.Rectangle qui représentent les rectangles à remplir.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Brush, RectangleF[])

Il remplit les intérieurs d’une série de rectangles spécifiées par Aspose.Imaging.RectangleF structures.

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

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

rects RectangleF [ ]

Le nombre de structures Aspose.Imaging.Rectangle qui représentent les rectangles à remplir.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Région)

Il remplit l’intérieur d’une Aspose.Imaging.Région.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

WL17_.Brush qui détermine les caractéristiques du remplissage.

region Region

Aspose.Imaging.Région qui représente la zone à remplir.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(Fontaine, StringFormat, SizeF)

Mesure la ligne de texte spécifiée avec des paramètres spécificés

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

Parameters

text string

Il testo da misurare.

font Font

Le chiffre à mesurer.

layoutArea SizeF

La zone de layout.

stringFormat StringFormat

Il formato string.

Returns

SizeF

Taille en pixels d’une ligne de texte mesurée

MultiplyTransform(Matrix)

Il multiplie le Aspose.Imaging.Matrix qui représente la transformation géométrique locale de ce Wl17.Graphics par le spécifié _www.matrix en prépondant le specificat _wl15_matrixe.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Le Aspose.Imaging.Matrix par lequel multiplier la transformation géométrique.

MultiplyTransform(Matrix et MatrixOrder)

Il multiplie le Aspose.Imaging.Matrix qui représente la transformation géométrique locale de ce WR17.Graphics par le spécifié _ WR18_ .Matrx dans l’ordre spécificé.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Le Aspose.Imaging.Matrix par lequel multiplier la transformation géométrique.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder qui spécifie dans quel but de multiplier les deux matrices.

ResetTransform()

Récupérer le Aspose.Imaging.Graphics.Transformer la propriété en identité.

public void ResetTransform()

RotateTransform(Flotte)

Rotage la transformation géométrique locale par la quantité spécifiée.Cette méthode prépare la rotation à la transformation.

public void RotateTransform(float angle)

Parameters

angle float

L’angolo della rotazione.

RotateTransform(Méditerranée MatrixOrder)

Rotage la transformation géométrique locale par la quantité spécifiée dans l’ordre spécifié.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

L’angolo della rotazione.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder qui spécifie s’il faut appliquer ou prépendre la matrice de rotation.

ScaleTransform(Fleur, fleur)

Scale la transformation géométrique locale par les quantités spécifiées.Cette méthode prépend la matrice d’échelle à la transformation.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

La quantité par laquelle évoluer la transformation dans la direction x-axis.

sy float

La quantité par laquelle évoluer la transformation dans la direction y-axis.

ScaleTransform(Flotte, Flotte, MatrixOrder)

Scale la transformation géométrique locale par les quantités spécifiées dans l’ordre spécifié.

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

Parameters

sx float

La quantité par laquelle évoluer la transformation dans la direction x-axis.

sy float

La quantité par laquelle évoluer la transformation dans la direction y-axis.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder qui spécifie s’il faut appliquer ou prépendre la matrice d’échelle.

TranslateTransform(Fleur, fleur)

Il traduit la transformation géométrique locale par les dimensions spécifiées.Cette méthode prépare la traduction à la transformation.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Il valore della traduzione in x.

dy float

Il valore della traduzione in y.

TranslateTransform(Flotte, Flotte, MatrixOrder)

Il traduit la transformation géométrique locale par les dimensions spécifiées dans l’ordre spécifié.

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

Parameters

dx float

Il valore della traduzione in x.

dy float

Il valore della traduzione in y.

order MatrixOrder

L’ordine (prepend o append) in cui applicare la traduzione.

 Français