Class Graphics

Class Graphics

De naam: Aspose.Imaging Verzameling: Aspose.Imaging.dll (25.4.0)

Vertegenwoordigt de graphics volgens de graphics engine die wordt gebruikt in de huidige assembly.

public sealed class Graphics

Inheritance

object Graphics

Geëerbiede leden

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

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Initialiseert een nieuwe instantie van de Aspose.Imaging.Graphics klasse.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

De bron van het beeld.

Properties

Clip

Geeft of zet de clip regio.

public Region Clip { get; set; }

Eigendomswaarde

Region

CompositingQuality

Geeft of stelt de compositiekwaliteit.

public CompositingQuality CompositingQuality { get; set; }

Eigendomswaarde

CompositingQuality

Dpix

Geeft de horizontale resolutie van dit Aspose.Imaging.Grafica.

public float DpiX { get; }

Eigendomswaarde

float

Dpi’s

Geeft de verticale resolutie van dit Aspose.Imaging.Grafica.

public float DpiY { get; }

Eigendomswaarde

float

Image

Krijg het beeld.

public Image Image { get; }

Eigendomswaarde

Image

InterpolationMode

Geeft of instelt de interpolatie modus.

public InterpolationMode InterpolationMode { get; set; }

Eigendomswaarde

InterpolationMode

IsInBeginUpdateCall

Geeft een waarde die aangeeft of de grafiek is in BeginUpdate call state.

public bool IsInBeginUpdateCall { get; }

Eigendomswaarde

bool

PageScale

Geeft of stelt de schaal tussen wereld- en pagina-eenheden voor dit Aspose.Imaging.Grafica.

public float PageScale { get; set; }

Eigendomswaarde

float

PageUnit

Geeft of stelt de eenheid van meting die wordt gebruikt voor pagina coördinaten in dit Aspose.Imaging.Grafiek.

public GraphicsUnit PageUnit { get; set; }

Eigendomswaarde

GraphicsUnit

PaintableImageOptions

Geeft of stelt afbeeldingsopties, gebruikt om kleurrijke vactor afbeeldingen te maken om te trekken.

public ImageOptionsBase PaintableImageOptions { get; set; }

Eigendomswaarde

ImageOptionsBase

SmoothingMode

Geeft of stelt de glijmingsmodus.

public SmoothingMode SmoothingMode { get; set; }

Eigendomswaarde

SmoothingMode

TextRenderingHint

Geeft of zet de tekst rendering in.

public TextRenderingHint TextRenderingHint { get; set; }

Eigendomswaarde

TextRenderingHint

Transform

Geeft of stelt een kopie van de geometrische wereldtransformatie voor dit Aspose.Imaging.Grafica.

public Matrix Transform { get; set; }

Eigendomswaarde

Matrix

Methods

BeginUpdate()

De grafische effecten die vervolgens worden toegepast, worden niet onmiddellijk toegepast, in plaats daarvan zal de EndUpdate alle effecten tegelijkertijd veroorzaken.

public void BeginUpdate()

Remarks

Let op de effecten na BeginUpdate wordt geroepen zal niet worden toegepast in het geval EndUpdate niet wordt geroepen.

Clear(Color)

Reinig de grafische oppervlakte met behulp van de aangegeven kleur.

public void Clear(Color color)

Parameters

color Color

De kleur om de grafische oppervlakte door te verwijderen.

Examples

Deze voorbeelden maken gebruik van de GraphicsPath en Grafica-klasse om Figuren op een afbeeldingsoppervlak te maken en te manipuleren. Example creëert een nieuwe Afbeelding (van type Tiff), schoonmaakt de oppervloer en trekt paden met behulp van grafica Path.

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

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een arc die een portie van een ellipse vertegenwoordigt, aangegeven door een paar coördinaten, een breedte en een hoogte.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de arc bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de rectangle die de ellips definieert.

y float

De y-koordinaat van de bovenste linker hoek van de rectangle die de ellips definieert.

width float

De breedte van de rectangle die de ellipse definieert.

height float

Hoogte van de rectangle die de ellipse definieert.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis tot het uitgangspunt van de arc.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter tot het eindpunt van de arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Draai een arc die een portie van een ellipse vertegenwoordigt, aangegeven door een Aspose.Imaging.RectangleF structuur.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de arc bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de grenzen van de ellipse definieert.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis tot het uitgangspunt van de arc.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter tot het eindpunt van de arc.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pen, int, int, int, int, int, int)

Draai een arc die een portie van een ellipse vertegenwoordigt, aangegeven door een paar coördinaten, een breedte en een hoogte.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de arc bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de rectangle die de ellips definieert.

y int

De y-koordinaat van de bovenste linker hoek van de rectangle die de ellips definieert.

width int

De breedte van de rectangle die de ellipse definieert.

height int

Hoogte van de rectangle die de ellipse definieert.

startAngle int

Winkel in graden gemeten klokwijze van de x-axis tot het uitgangspunt van de arc.

sweepAngle int

Winkel in graden gemeten klokwijze van de startAngle’ parameter tot het eindpunt van de arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, rectangle, float, float)

Draai een arc die een portie van een ellipse vertegenwoordigt, aangegeven door een Aspose.Imaging.Rectangle structuur.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de arc bepaalt.

rect Rectangle

Aspose.Imaging.RectangleF structuur die de grenzen van de ellipse definieert.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis tot het uitgangspunt van de arc.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter tot het eindpunt van de arc.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een Bézier spline gedefinieerd door vier bestelde paarden van coördinaten die punten vertegenwoordigen.

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 die de kleur, breedte en stijl van de curve bepaalt.

x1 float

De x-koordinaat van het startpunt van de curve.

y1 float

De y-koordinaat van het startpunt van de curve.

x2 float

De x-koordinaat van het eerste controlepunt van de curve.

y2 float

De y-koordinaat van het eerste controlepunt van de curve.

x3 float

De x-koordinaat van het tweede controlepunt van de curve.

y3 float

De y-koordinaat van het tweede controlepunt van de curve.

x4 float

De x-koordinaat van het eindpunt van de curve.

y4 float

De y-koordinaat van het eindpunt van de curve.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(PointF, PointF, PointF en PointF)

Draai een Bézier spline gedefinieerd door vier Aspose.Imaging.PointF structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de curve bepaalt.

pt1 PointF

Aspose.Imaging.PointF structuur die het beginpunt van de curve vertegenwoordigt.

pt2 PointF

Aspose.Imaging.PointF-structuur die het eerste controlepunt voor de curve vertegenwoordigt.

pt3 PointF

Aspose.Imaging.PointF-structuur die het tweede controlepunt voor de curve vertegenwoordigt.

pt4 PointF

Aspose.Imaging.PointF structuur die het eindpunt van de curve vertegenwoordigt.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pijn, punt, punt en punt)

Draai een Bézier spline gedefinieerd door vier Aspose.Imaging.Point structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen structuur die de kleur, breedte en stijl van de curve bepaalt.

pt1 Point

Aspose.Imaging.Pointstructuur die het beginpunt van de curve vertegenwoordigt.

pt2 Point

Aspose.Imaging.Pointstructuur die het eerste controlepunt voor de curve vertegenwoordigt.

pt3 Point

Aspose.Imaging.Pointstructuur die het tweede controlepunt voor de curve vertegenwoordigt.

pt4 Point

Aspose.Imaging.Pointstructuur die het eindpunt van de curve vertegenwoordigt.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

//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(Het punt, punt[])

Drukt een reeks Bézier splines uit een aantal Aspose.Imaging.Point structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de punten vertegenwoordigen die het curve bepalen.

Exceptions

ArgumentNullException

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

DrawBeziers(Hoofdstuk, PointF[])

Drukt een reeks Bézier splines uit een aantal Aspose.Imaging.PointF structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de punten vertegenwoordigen die het curve bepalen.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Hoofdstuk, PointF[])

Draai een gesloten cardinaal spline gedefinieerd door een reeks van Aspose.Imaging.PointF structuren. Deze methode gebruikt een standaardspanning van 0.5 en W L17.FillMode.Alternate vullen modus.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Hoofdstuk, PointF[], De vloot)

Draai een gesloten cardinaal spline gedefinieerd door een reeks van Aspose.Imaging.PointF structuren met behulp van een specifieke spanning. Deze methode gebruikt een standaard WR17.FillMode.Alternate vullen modus.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Het punt, punt[])

Draai een gesloten cardinaal spline gedefinieerd door een reeks van Aspose.Imaging.Point structuren. Deze methode gebruikt een standaardspanning van 0.5 en W L17.FillMode.Alternate vullen modus.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Het punt, punt[], De vloot)

Draai een gesloten cardinaal spline gedefinieerd door een reeks van Aspose.Imaging.Point structuren met behulp van een specifieke spanning. Deze methode gebruikt een standaard WR17.FillMode.Alternate vullen modus.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawCurve(Hoofdstuk, PointF[])

Draai een kardinaal spline door een specifieke reeks van Aspose.Imaging.PointF structuren. Deze methode gebruikt een standaardspanning van 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

Exceptions

ArgumentNullException

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

DrawCurve(Hoofdstuk, PointF[], De vloot)

Draai een kardinaal spline door een specifieke reeks van Aspose.Imaging.PointF structuren met behulp van een bepaalde spanning.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de punten vertegenwoordigen die het curve definiëren.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawCurve(Hoofdstuk, PointF[], int , int)

Draai een kardinaal spline door een specifieke reeks van Aspose.Imaging.PointF structuren.Deze methode gebruikt een standaardspanning van 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

offset int

Afschakelen van het eerste element in de volgorde van de punten’ parameter naar het uitgangspunt in de curve.

numberOfSegments int

Aantal segmenten na het startpunt om in de curve te worden opgenomen.

Exceptions

ArgumentNullException

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

DrawCurve(Hoofdstuk, PointF[], int , int , float)

Draai een kardinaal spline door een specifieke reeks van Aspose.Imaging.PointF structuren met behulp van een bepaalde spanning.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

offset int

Afschakelen van het eerste element in de volgorde van de punten’ parameter naar het uitgangspunt in de curve.

numberOfSegments int

Aantal segmenten na het startpunt om in de curve te worden opgenomen.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawCurve(Het punt, punt[])

Draai een kardinaal spline door een specifieke reeks van Aspose.Imaging.Point structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

//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(Het punt, punt[], De vloot)

Draai een kardinaal spline door een bepaalde reeks van Aspose.Imaging.Point structuren met een specifieke spanning.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawCurve(Het punt, punt[], int , int , float)

Draai een kardinaal spline door een bepaalde reeks van Aspose.Imaging.Point structuren met een specifieke spanning.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en hoogte van de curve bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

offset int

Afschakelen van het eerste element in de volgorde van de punten’ parameter naar het uitgangspunt in de curve.

numberOfSegments int

Aantal segmenten na het startpunt om in de curve te worden opgenomen.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

DrawEllipse(Pen, RectangleF)

Draai een ellips gedefinieerd door een bounding Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de ellipse bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de grenzen van de ellipse definieert.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, float, float, float, float)

Draai een ellips gedefinieerd door een boundering rectangle gedefinieerd door een paar coördinaten, een hoogte en een breedte.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de ellipse bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de boundering rectangle die de ellipse definieert.

y float

De y-koordinaat van de bovenste linker hoek van de boundante rectangle die de ellips definieert.

width float

De breedte van de boundary rectangle die de ellipse definieert.

height float

Hoogte van de boundary rectangle die de ellipse definieert.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, rectangle)

Draai een ellips gedefinieerd door een bounding Aspose.Imaging.Rectangle structuur.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de ellipse bepaalt.

rect Rectangle

Aspose.Imaging.Rectangle structuur die de grenzen van de ellipse definieert.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een ellips gedefinieerd door een boundering rectangle gedefinieerd door een paar coördinaten, een hoogte en een breedte.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de ellipse bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de boundering rectangle die de ellipse definieert.

y int

De y-koordinaat van de bovenste linker hoek van de boundante rectangle die de ellips definieert.

width int

De breedte van de boundary rectangle die de ellipse definieert.

height int

Hoogte van de boundary rectangle die de ellipse definieert.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Afbeelding PointF)

Draag de aangegeven Aspose.Imaging.Graphics.Image, met behulp van zijn oorspronkelijke fysieke grootte, op de gegeven locatie.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

point PointF

Aspose.Imaging.PointF structuur die de bovenste linker hoek van het getransporteerde beeld vertegenwoordigt.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, Float, Float)

Draag de aangegeven Aspose.Imaging.Graphics.Image, met behulp van zijn oorspronkelijke fysieke grootte, op de gegeven locatie.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x float

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y float

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, RectangleF)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de locatie en de grootte van het getransporteerde beeld specificeren.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, Rectangle, GraphicsUnit)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectDestination Rectangle

De bestemming rectangle.

graphicsUnit GraphicsUnit

De grafische eenheid.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, RectangleF, GraphicsUnit)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectDestination RectangleF

De bestemming rectangle.

graphicsUnit GraphicsUnit

De grafische eenheid.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, Rectangle, GraphicsUnit, ImageAttributes)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectDestination Rectangle

De bestemming rectangle.

graphicsUnit GraphicsUnit

De grafische eenheid.

imageAttributes ImageAttributes

De afbeelding heeft attributen.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, RectangleF, GraphicsUnit, ImageAttributes)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectDestination RectangleF

De bestemming rectangle om in te trekken.

graphicsUnit GraphicsUnit

De grafische eenheid.

imageAttributes ImageAttributes

De afbeelding heeft attributen.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, Rectangle, Rectangle, GraphicsUnit)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectSource Rectangle

De rect bron.

rectDestination Rectangle

De rect bestemming.

graphicsUnit GraphicsUnit

De grafische eenheid.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, RectangleF, RectangleF, GraphicsUnit)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectSource RectangleF

De rect bron.

rectDestination RectangleF

De rect bestemming.

graphicsUnit GraphicsUnit

De grafische eenheid.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectSource Rectangle

De rect bron.

rectDestination Rectangle

De rect bestemming.

graphicsUnit GraphicsUnit

De grafische eenheid.

imageAttributes ImageAttributes

De afbeelding heeft attributen.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rectSource RectangleF

De bron rectangle.

rectDestination RectangleF

De bestemming rectangle.

graphicsUnit GraphicsUnit

De grafische eenheid te gebruiken.

imageAttributes ImageAttributes

De afbeelding wordt toegeschreven om te gebruiken.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, punt[])

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints Point []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

DrawImage(Afbeelding, punt[], De rectangle)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints Point []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect Rectangle

De bron rectangle.

DrawImage(Afbeelding, punt[], Rectangle, GraphicsUnit)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints Point []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect Rectangle

De bron rectangle.

srcUnit GraphicsUnit

De eenheden van de meting.

DrawImage(Afbeelding, punt[], Rectangle, GraphicsUnit, ImageAttributes)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints Point []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect Rectangle

De bron rectangle.

srcUnit GraphicsUnit

De eenheden van de meting.

imageAttributes ImageAttributes

De afbeelding heeft attributen.

DrawImage(Afbeelding PointF[])

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints PointF []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

Exceptions

ArgumentNullException

afbeelding

DrawImage(Afbeelding PointF[], RectangleF)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints PointF []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect RectangleF

De bron rectangle.

DrawImage(Afbeelding PointF[], RectangleF, GraphicsUnit)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints PointF []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect RectangleF

De bron rectangle.

srcUnit GraphicsUnit

De eenheden van de meting.

DrawImage(Afbeelding PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Draai de aangegeven portie van de aangegeven image’ op de aangegeven locatie en met de aangegeven grootte.

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

Parameters

image Image

Het beeld om te draaien.

destPoints PointF []

Een reeks van drie PointF-structuren die een parallelogram definiëren.

srcRect RectangleF

De bron rectangle.

srcUnit GraphicsUnit

De eenheden van de meting.

imageAttributes ImageAttributes

De afbeelding heeft attributen.

DrawImage(Foto, vloot, vloot, vloot, vloot)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x float

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y float

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

width float

De breedte van het getrokken beeld.

height float

Hoogte van de afgebeelde afbeelding.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, punt)

Draag de aangegeven Aspose.Imaging.Graphics.Image, met behulp van zijn oorspronkelijke fysieke grootte, op de gegeven locatie.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

point Point

Aspose.Imaging.Pointstructuur die de locatie van de bovenste linker hoek van het getransporteerde beeld vertegenwoordigt.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, int, int)

Draai de aangegeven afbeelding, met behulp van de oorspronkelijke fysieke grootte, op de door een coördinatiepaar aangegeven locatie.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x int

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y int

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, rectangle)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rect Rectangle

Aspose.Imaging.Rectangle structuur die de locatie en de grootte van de getransporteerde afbeelding bepaalt.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Afbeelding, int, int, int)

Draai de aangegeven Aspose.Imaging.Graphics.Image op de gegeven locatie en met de gemotiveerde grootte.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x int

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y int

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

width int

De breedte van het getrokken beeld.

height int

Hoogte van de afgebeelde afbeelding.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Afbeelding, punt)

Draag een bepaalde afbeelding met behulp van de oorspronkelijke fysieke grootte op een bepaalde locatie.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

point Point

Aspose.Imaging.Pointstructuur die de bovenste linker hoek van het getransporteerde afbeelding bepaalt.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Afbeelding, int, int)

Draai de aangegeven afbeelding met behulp van de oorspronkelijke fysieke grootte op de door een coördinatiepaar aangegeven locatie.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x int

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y int

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Afbeelding, rectangle)

Draag een bepaalde afbeelding met behulp van de oorspronkelijke fysieke grootte op een bepaalde locatie.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rect Rectangle

Aspose.Imaging.Rectangle dat de bovenste linker hoek van de getransporteerde afbeelding bepaalt.De eigenschappen X en Y van het rectangel bepalen de boven-lechtshoek.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Afbeelding, int, int, int)

Draag een bepaalde afbeelding met behulp van de oorspronkelijke fysieke grootte op een bepaalde locatie.

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

Parameters

sourceImage Image

De afbeelding om mee te trekken.

x int

De x-coordinaat van de bovenste linker hoek van de getoonde afbeelding.

y int

De y-koordinaat van de bovenste linker hoek van de getoonde afbeelding.

width int

De parameter wordt niet gebruikt.

height int

De parameter wordt niet gebruikt.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Afbeelding, rectangle)

Draai de aangegeven afbeelding zonder te scalen en clips het, indien nodig, om in de aangegeven rectangle te passen.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

De afbeelding om mee te trekken.

rect Rectangle

De Aspose.Imaging.Rectangle waarin de afbeelding te trekken.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Pijn, punt en punt)

Draai een lijn die twee Aspose.Imaging.Point structuren verbindt.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijn bepaalt.

point1 Point

Aspose.Imaging.Pointstructuur die het eerste punt vertegenwoordigt om verbinding te maken.

point2 Point

Aspose.Imaging.Pointstructuur die het tweede punt vertegenwoordigt om verbinding te maken.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een lijn die twee Aspose.Imaging.PointF structuren verbindt.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijn bepaalt.

point1 PointF

Aspose.Imaging.PointF-structuur die het eerste punt vertegenwoordigt om verbinding te maken.

point2 PointF

Aspose.Imaging.PointF structuur die het tweede punt vertegenwoordigt om verbinding te maken.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, int, int, int, int)

Draai een lijn die de twee punten verbindt die door de coördinatieparen worden aangegeven.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijn bepaalt.

x1 int

De x-coördinatie van het eerste punt.

y1 int

De coördinatie van het eerste punt.

x2 int

De x-coördinatie van het tweede punt.

y2 int

De coördinatie van het tweede punt.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, float, float, float, float)

Draai een lijn die de twee punten verbindt die door de coördinatieparen worden aangegeven.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijn bepaalt.

x1 float

De x-coördinatie van het eerste punt.

y1 float

De coördinatie van het eerste punt.

x2 float

De x-coördinatie van het tweede punt.

y2 float

De coördinatie van het tweede punt.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Het punt, punt[])

Draai een reeks lijnsegmenten die een aantal Aspose.Imaging.Point-structuren verbinden.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijnsegmenten bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de punten vertegenwoordigen om verbinding te maken.

Exceptions

ArgumentNullException

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

ArgumentException

De punten’ array bevat minder dan 2 punten.

DrawLines(Hoofdstuk, PointF[])

Het draait een reeks lijnsegmenten die een aantal Aspose.Imaging.PointF structuren verbinden.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de lijnsegmenten bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de punten om te verbinden vertegenwoordigen.

Exceptions

ArgumentNullException

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

ArgumentException

De punten’ array bevat minder dan 2 punten.

DrawPath(Pijn, GraphicsPath)

Draai een Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de route bepaalt.

path GraphicsPath

Aspose.Imaging.GraphicsPath om te trekken.

Examples

Deze voorbeelden maken gebruik van de GraphicsPath en Grafica-klasse om Figuren op een afbeeldingsoppervlak te maken en te manipuleren. Example creëert een nieuwe Afbeelding (van type Tiff), schoonmaakt de oppervloer en trekt paden met behulp van grafica Path.

//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(Pen, RectangleF, float, float)

Draai een pie-vorm gedefinieerd door een ellipse aangegeven door de Aspose.Imaging.RectangleF structuur en twee radiale lijnen.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de pie vorm bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de boundante rectangel vertegenwoordigt dat de ellipse definieert waaruit de pie-vorm vandaan komt.

startAngle float

Winkel gemeten in graden klokwijze van de x-axis naar de eerste kant van de pie-vorm.

sweepAngle float

Winkel gemeten in graden klokwijze van de startAngle’ parameter naar de tweede kant van de pie-vorm.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pijn, vloot, vloot, vloot, vloot, vloot, vloot)

Draai een pie-vorm gedefinieerd door een ellipse aangegeven door een coördinatiepaar, een breedte, een hoogte en twee radiale lijnen.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de pie vorm bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie-vorm vandaan komt.

y float

De y-koordinaat van de bovenste linker hoek van de boord rectangle die de ellipses bepaalt waaruit de pie-vorm vandaan komt.

width float

De breedte van de boundary rectangle die de ellipse bepaalt waaruit de pie-vorm komt.

height float

Hoogte van de boundary rectangle die de ellipse bepaalt waaruit de pie vorm komt.

startAngle float

Winkel gemeten in graden klokwijze van de x-axis naar de eerste kant van de pie-vorm.

sweepAngle float

Winkel gemeten in graden klokwijze van de startAngle’ parameter naar de tweede kant van de pie-vorm.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, rectangle, float, float)

Draai een pie-vorm gedefinieerd door een ellipse aangegeven door de Aspose.Imaging.Rectangle structuur en twee radiale lijnen.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de pie vorm bepaalt.

rect Rectangle

Aspose.Imaging.Rectangle structuur dat de boundering rectangel vertegenwoordigt die de ellipse definieert waaruit de pie-vorm vandaan komt.

startAngle float

Winkel gemeten in graden klokwijze van de x-axis naar de eerste kant van de pie-vorm.

sweepAngle float

Winkel gemeten in graden klokwijze van de startAngle’ parameter naar de tweede kant van de pie-vorm.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een pie-vorm gedefinieerd door een ellipse aangegeven door een coördinatiepaar, een breedte, een hoogte en twee radiale lijnen.

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

Parameters

pen Pen

Aspose.Imaging.Pen die de kleur, breedte en stijl van de pie vorm bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie-vorm vandaan komt.

y int

De y-koordinaat van de bovenste linker hoek van de boord rectangle die de ellipses bepaalt waaruit de pie-vorm vandaan komt.

width int

De breedte van de boundary rectangle die de ellipse bepaalt waaruit de pie-vorm komt.

height int

Hoogte van de boundary rectangle die de ellipse bepaalt waaruit de pie vorm komt.

startAngle int

Winkel gemeten in graden klokwijze van de x-axis naar de eerste kant van de pie-vorm.

sweepAngle int

Winkel gemeten in graden klokwijze van de startAngle’ parameter naar de tweede kant van de pie-vorm.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Hoofdstuk, PointF[])

Draai een polygon gedefinieerd door een reeks Aspose.Imaging.PointF structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van het polygon bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de verticals van het polygon vertegenwoordigen.

Exceptions

ArgumentNullException

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

DrawPolygon(Het punt, punt[])

Draai een polygon gedefinieerd door een reeks Aspose.Imaging.Point structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van het polygon bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de verticals van het polygon vertegenwoordigen.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een rectangle aangegeven door een Aspose.Imaging.RectanglesF structuur.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Een Aspose.Imaging.Pen dat de kleur, breedte en stijl van de rectangle bepaalt.

rect RectangleF

Een Aspose.Imaging.RectangleF structuur die de rectangel vertegenwoordigt om te trekken.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, rectangle)

Draai een rectangle aangegeven door een Aspose.Imaging.Rectangel structuur.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Een Aspose.Imaging.Pen dat de kleur, breedte en stijl van de rectangle bepaalt.

rect Rectangle

Een Aspose.Imaging.Rectangle structuur die de rectangel vertegenwoordigt om te trekken.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai een rectangle aangegeven door een coördinatiepaar, een breedte en een hoogte.

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

Parameters

pen Pen

Een Aspose.Imaging.Pen dat de kleur, breedte en stijl van de rectangle bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de rectangle om te trekken.

y float

De y-koordinaat van de bovenste linker hoek van de rectangle om te trekken.

width float

De breedte van de rectangle om te trekken.

height float

De hoogte van de rectangle om te trekken.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, int, int, int, int)

Draai een rectangle aangegeven door een coördinatiepaar, een breedte en een hoogte.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de rectangle bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de rectangle om te trekken.

y int

De y-koordinaat van de bovenste linker hoek van de rectangle om te trekken.

width int

De breedte van de rectangle om te trekken.

height int

Hoogte van de rectangle om te trekken.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pen, RectangleF[])

Het draagt een rectangelserie dat wordt aangegeven door Aspose.Imaging.RectangleF structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de outlines van het rectangle bepaalt.

rects RectangleF []

Een reeks van Aspose.Imaging.RectangleF structuren die de rectangels vertegenwoordigen om te trekken.

Exceptions

ArgumentNullException

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

DrawRectangles(Pen, rectangle[])

Het draagt een rectangelserie aangegeven door Aspose.Imaging.Rectangle structuren.

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

Parameters

pen Pen

Aspose.Imaging.Pen dat de kleur, breedte en stijl van de outlines van het rectangle bepaalt.

rects Rectangle []

Een reeks van Aspose.Imaging.Rectangle structuren die de rectangels vertegenwoordigen om te trekken.

Examples

Dit voorbeeld toont de creatie en het gebruik van Pen objecten.Het voorwerp creëert een nieuw beeld en draagt Rectangles op de oppervlakte van het beeld.

//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(String, Font, Brush, Float, Float)

Draai de gespecificeerde tekstlijn op de aangegeven locatie met de specifieke Aspose.Imaging.Brush en WR17.Font objecten.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

x float

De x-koordinaat van de bovenste linker hoek van de getekende tekst.

y float

De y-koordinaat van de bovenste linker hoek van de getekende tekst.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush en PointF)

Draai de gespecificeerde tekstlijn op de aangegeven locatie met de specifieke Aspose.Imaging.Brush en WR17.Font objecten.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

point PointF

Aspose.Imaging.PointF structuur die de bovenste linker hoek van de getekende tekst bepaalt.

Examples

Dit voorbeeld gebruikt de Graphics-klasse om primitieve vormen op het beeldoppervlak te creëren. om de werking te demonstreren, creëert het model een nieuw beeld in PNG-formaat en draagt primitief vormes op de beeldovergrond met behulp van Draw methoden die worden blootgesteld door de grafische klasse.

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

Draai de gespecificeerde tekstlijn op de aangegeven locatie met de geconstateerde Aspose.Imaging.Brush en WR17.Font-objecten met behulp van de formatting attributen van het geconcentreerde _www.StringFormat.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

x float

De x-koordinaat van de bovenste linker hoek van de getekende tekst.

y float

De y-koordinaat van de bovenste linker hoek van de getekende tekst.

format StringFormat

Aspose.Imaging.StringFormat dat formatting attributen, zoals line spacing en alignment, die worden toegepast op de getekende tekst specificeren.

Exceptions

ArgumentNullException

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

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

Draai de gespecificeerde tekstlijn op de aangegeven locatie met de geconstateerde Aspose.Imaging.Brush en WR17.Font-objecten met behulp van de formatting attributen van het geconcentreerde _www.StringFormat.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

point PointF

Aspose.Imaging.PointF structuur die de bovenste linker hoek van de getekende tekst bepaalt.

format StringFormat

Aspose.Imaging.StringFormat dat formatting attributen, zoals line spacing en alignment, die worden toegepast op de getekende tekst specificeren.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, RectangleF)

Draai de gespecificeerde tekstlijn in de aangegeven rectangle met de specifieke Aspose.Imaging.Brush en WR17.Font objecten.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structuur die de locatie van de getekende tekst aangeeft.

Exceptions

ArgumentNullException

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

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

Draai de gespecificeerde tekstlijn in de aangegeven rectangle met de specifieke Aspose.Imaging.Brush en WR17.Font-objecten met behulp van de formatting attributen van het specifiek __ WL16_ .StringFormat.

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

Parameters

s string

String om te trekken.

font Font

Aspose.Imaging.Font dat het tekstformaat van de string definieert.

brush Brush

Aspose.Imaging.Brush die de kleur en textuur van de getekende tekst bepaalt.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structuur die de locatie van de getekende tekst aangeeft.

format StringFormat

Aspose.Imaging.StringFormat dat formatting attributen, zoals line spacing en alignment, die worden toegepast op de getekende tekst specificeren.

Exceptions

ArgumentNullException

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

EndUpdate()

Het beëindigen van de caching van de grafische operaties begonnen na BeginUpdate werd geroepen. de voorafgaande grafische operaties zullen tegelijkertijd worden toegepast bij het roepen van deze methode.

public void EndUpdate()

FillClosedCurve(Brush en PointF[])

Vult het interieur van een gesloten cardinaal spline curve gedefinieerd door een reeks van Aspose.Imaging.PointF structuren. Deze methode gebruikt een standaardspanning van 0.5 en W L17.FillMode.Alternate vullen modus.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush en PointF[], De FillMode)

Vul het interieur van een gesloten kardinaal spline curve gedefinieerd door een reeks Aspose.Imaging.PointF structuren met behulp van de aangegeven vullen modus. Deze methode gebruikt een standaard spanning van 0.5.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

fillMode FillMode

Lid van de Aspose.Imaging.FillMode lijst die bepaalt hoe de curve wordt gevuld.

Exceptions

ArgumentNullException

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

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

Vul het interieur van een gesloten cardinaal spline curve gedefinieerd door een reeks Aspose.Imaging.PointF structuren met behulp van de aangegeven vullen modus en spanning.

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

Parameters

brush Brush

Een Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de spline definiëren.

fillmode FillMode

Lid van de Aspose.Imaging.FillMode lijst die bepaalt hoe de curve wordt gevuld.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush, punt[])

Vult het interieur van een gesloten kardinaal spline curve gedefinieerd door een reeks van Aspose.Imaging.Point structuren. Deze methode gebruikt een standaardspanning van 0.5 en W L17.FillMode.Alternate vullen modus.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush, punt[], De FillMode)

Vul het interieur van een gesloten kardinaal spline curve gedefinieerd door een reeks van Aspose.Imaging.Point structuren met behulp van de aangegeven vullen modus.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

fillmode FillMode

Lid van de Aspose.Imaging.FillMode lijst die bepaalt hoe de curve wordt gevuld.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush, punt[], FillMode , Float)

Vul het interieur van een gesloten kardinaal spline curve gedefinieerd door een reeks van Aspose.Imaging.Point structuren met behulp van de aangegeven vullen modus en spanning.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de spline definiëren.

fillmode FillMode

Lid van de Aspose.Imaging.FillMode lijst die bepaalt hoe de curve wordt gevuld.

tension float

Waarde groter dan of gelijk aan 0.0F dat de spanning van de curve bepaalt.

Exceptions

ArgumentNullException

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

FillEllipse(Brush en RectangleF)

Vult het interieur van een ellips gedefinieerd door een bounding rectangle aangegeven door de Aspose.Imaging.RectangelF structuur.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de boundering rectangel vertegenwoordigt die het ellipse definieert.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush, float, float, float, float)

Vult het interieur van een ellips gedefinieerd door een boundering rectangle gedefinieerd door een paar coördinaten, een breedte en een hoogte.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de boundering rectangle die de ellipse definieert.

y float

De y-koordinaat van de bovenste linker hoek van de boundante rectangle die de ellips definieert.

width float

De breedte van de boundary rectangle die de ellipse definieert.

height float

Hoogte van de boundary rectangle die de ellipse definieert.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush en rectangle)

Vult het interieur van een ellips gedefinieerd door een bounding rectangle aangegeven door de Aspose.Imaging.Rectangel structuur.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect Rectangle

Aspose.Imaging.Rectangle structuur die de boundering rectangel vertegenwoordigt die het ellipse definieert.

Exceptions

ArgumentNullException

brush’ is null.

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

Vult het interieur van een ellips gedefinieerd door een boundering rectangle gedefinieerd door een paar coördinaten, een breedte en een hoogte.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de boundering rectangle die de ellipse definieert.

y int

De y-koordinaat van de bovenste linker hoek van de boundante rectangle die de ellips definieert.

width int

De breedte van de boundary rectangle die de ellipse definieert.

height int

Hoogte van de boundary rectangle die de ellipse definieert.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Brush en GraphicsPath)

Vul het interieur van een Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

path GraphicsPath

Aspose.Imaging.GraphicsPath dat de weg vertegenwoordigt om te vullen.

Exceptions

ArgumentNullException

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

FillPie(Brush, rectangle, float, float)

Vult het interieur van een pie sectie gedefinieerd door een ellipse aangegeven door de Aspose.Imaging.RectangleF structuur en twee radiale lijnen.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect Rectangle

Aspose.Imaging.Rectangle structuur dat de boundering rectangel vertegenwoordigt die de ellipse definieert waaruit de pie sectie komt.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis naar de eerste kant van de pie sectie.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter naar de tweede kant van de pie sectie.

Examples

Het volgende voorbeeld toont hoe je een geanimeerde GIF-afbeelding kunt composeren van individuele Gif-blocks.

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)

Vult het interieur van een pie sectie gedefinieerd door een ellipse aangegeven door de Aspose.Imaging.RectangleF structuur en twee radiale lijnen.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de boundante rectangel vertegenwoordigt dat de ellipse definieert waaruit de pie sectie vandaan komt.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis naar de eerste kant van de pie sectie.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter naar de tweede kant van de pie sectie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Brouwerij, float, float, float, float, float)

Het vult het interieur van een pie sectie gedefinieerd door een ellips gedefinieerd door een paar coördinaten, een breedte, een hoogte en twee radiale lijnen.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

y float

De y-koordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

width float

De breedte van de boundary rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

height float

Hoogte van de boundary rectangle die de ellipse bepaalt waaruit de pie sectie komt.

startAngle float

Winkel in graden gemeten klokwijze van de x-axis naar de eerste kant van de pie sectie.

sweepAngle float

Winkel in graden gemeten klokwijze van de startAngle’ parameter naar de tweede kant van de pie sectie.

Exceptions

ArgumentNullException

brush’ is null.

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

Het vult het interieur van een pie sectie gedefinieerd door een ellips gedefinieerd door een paar coördinaten, een breedte, een hoogte en twee radiale lijnen.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

y int

De y-koordinaat van de bovenste linker hoek van de boord rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

width int

De breedte van de boundary rectangle die de ellipse bepaalt waaruit de pie sectie vandaan komt.

height int

Hoogte van de boundary rectangle die de ellipse bepaalt waaruit de pie sectie komt.

startAngle int

Winkel in graden gemeten klokwijze van de x-axis naar de eerste kant van de pie sectie.

sweepAngle int

Winkel in graden gemeten klokwijze van de startAngle’ parameter naar de tweede kant van de pie sectie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush en PointF[])

Vul het interieur van een polygon gedefinieerd door een reeks punten aangegeven door de Aspose.Imaging.PointF structuren en _www.fillmode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de verticals van het polygon vertegenwoordigen om te vullen.

Exceptions

ArgumentNullException

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

FillPolygon(Brush en PointF[], De FillMode)

Vullen het interieur van een polygon gedefinieerd door een reeks punten aangegeven door Aspose.Imaging.PointF structuren met behulp van de specifieke vullen modus.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points PointF []

Een reeks van Aspose.Imaging.PointF structuren die de verticals van het polygon vertegenwoordigen om te vullen.

fillMode FillMode

Lid van de Aspose.Imaging.FillMode lijst die de stijl van het vullen bepaalt.

Exceptions

ArgumentNullException

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

FillPolygon(Brush, punt[])

Vul het interieur van een polygon gedefinieerd door een reeks punten aangegeven door de Aspose.Imaging.Point structuren en W L 17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de verticals van het polygon vertegenwoordigen om te vullen.

Exceptions

ArgumentNullException

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

FillPolygon(Brush, punt[], De FillMode)

Vullen het interieur van een polygon gedefinieerd door een reeks punten aangegeven door Aspose.Imaging.Point structuren met behulp van de specifieke vullen modus.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

points Point []

Een reeks van Aspose.Imaging.Point structuren die de verticals van het polygon vertegenwoordigen om te vullen.

fillMode FillMode

Lid van de Aspose.Imaging.FillMode lijst die de stijl van het vullen bepaalt.

Exceptions

ArgumentNullException

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

FillRectangle(Brush en rectangle)

Vult het interieur van een rectangle vastgesteld door een Aspose.Imaging.Rectangel structuur.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect Rectangle

Aspose.Imaging.Rectangle structuur die de rectangel vertegenwoordigt om te vullen.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush en RectangleF)

Vult het interieur van een rectangle aangegeven door een Aspose.Imaging.RectangelF structuur.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rect RectangleF

Aspose.Imaging.RectangleF structuur die de rectangel vertegenwoordigt om te vullen.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, float, float, float, float)

Vult het interieur van een rectangle vastgesteld door een paar coördinaten, een breedte en een hoogte.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x float

De x-coordinaat van de bovenste linker hoek van de rectangle om te vullen.

y float

De y-koordinaat van de bovenste linker hoek van de rectangle om te vullen.

width float

De breedte van de rectangle om te vullen.

height float

Hoogte van de rectangle om te vullen.

Exceptions

ArgumentNullException

brush’ is null.

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

Vult het interieur van een rectangle vastgesteld door een paar coördinaten, een breedte en een hoogte.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

x int

De x-coordinaat van de bovenste linker hoek van de rectangle om te vullen.

y int

De y-koordinaat van de bovenste linker hoek van de rectangle om te vullen.

width int

De breedte van de rectangle om te vullen.

height int

Hoogte van de rectangle om te vullen.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush en rectangle[])

Het vult de interieurs van een rectangelserie vastgesteld door Aspose.Imaging.Rectangle structuren.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rects Rectangle []

Een reeks van Aspose.Imaging.Rectangle structuren die de rectangels vertegenwoordigen om te vullen.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Brush en RectangleF[])

Het vult de interieurs van een rectangelserie aangegeven door Aspose.Imaging.RectangleF structuren.

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

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

rects RectangleF []

Een reeks van Aspose.Imaging.Rectangle structuren die de rectangels vertegenwoordigen om te vullen.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, regio)

Vuld het interieur van een Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush die de kenmerken van de vullen bepaalt.

region Region

Aspose.Imaging.De regio die het gebied vertegenwoordigt om te vullen.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(string, Font, SizeF, StringFormat)

Het meten van de gespecificeerde tekstlijn met specifieke parameters

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

Parameters

text string

De tekst te meten.

font Font

De font om te meten.

layoutArea SizeF

Het layoutgebied.

stringFormat StringFormat

Het string formaat.

Returns

SizeF

Grootte in pixels van gemeten tekstlijn

MultiplyTransform(Matrix)

Vermenigvuldigt het Aspose.Imaging.Matrix dat de plaatselijke geometrische transformatie van dit W L 17.Grafiek vertegenwoordigt door het specifieke _ W L 18_ .Matriks door te prependeren de specificeerde _ www.wl 17 _.matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

De Aspose.Imaging.Matrix door welke de geometrische transformatie te vermenigvuldigen.

MultiplyTransform(Matrix en MatrixOrder)

Vermenigvuldigt het Aspose.Imaging.Matrix dat de plaatselijke geometrische transformatie van dit W L 17.Grafiek vertegenwoordigt door het specifieke _ W L 18_ .Matrx in de specificeerde volgorde.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

De Aspose.Imaging.Matrix door welke de geometrische transformatie te vermenigvuldigen.

order MatrixOrder

Een Aspose.Imaging.MatrixOrder die bepaalt in welk doel de twee matrices te vermenigvuldigen.

ResetTransform()

Het herstelt de Aspose.Imaging.Graphics.Transformeert eigendom naar identiteit.

public void ResetTransform()

RotateTransform(Vloot)

Roteren de lokale geometrische transformatie door de aangegeven hoeveelheid. deze methode verhoogt de rotatie naar de transformatie.

public void RotateTransform(float angle)

Parameters

angle float

De hoek van de rotatie.

RotateTransform(Vliegtuigen, MatrixOrder)

Roteren de lokale geometrische transformatie door de aangegeven hoeveelheid in de aangegeven volgorde.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

De hoek van de rotatie.

order MatrixOrder

Een Aspose.Imaging.MatrixOrder waarin wordt aangegeven of de rotatiematrix moet worden aangepast of voorbereid.

ScaleTransform(De vloot, de vloot)

Scaleer de lokale geometrische transformatie door de aangegeven hoeveelheden. deze methode legt de scaleermatrix aan de transformatie.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

De hoeveelheid waarmee de transformatie in de x-axis richting te scalen.

sy float

De hoeveelheid waarmee de transformatie in de y-axis richting te scalen.

ScaleTransform(vloat, vloat, matrixOrder)

Scaleer de lokale geometrische transformatie door de aangegeven hoeveelheden in de aangegeven volgorde.

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

Parameters

sx float

De hoeveelheid waarmee de transformatie in de x-axis richting te scalen.

sy float

De hoeveelheid waarmee de transformatie in de y-axis richting te scalen.

order MatrixOrder

Een Aspose.Imaging.MatrixOrder waarin wordt aangegeven of de schaalmatrix moet worden aangevuld of voorbereid.

TranslateTransform(De vloot, de vloot)

Het vertelt de plaatselijke geometrische transformatie door de aangegeven dimensies. deze methode legt de vertaling aan de transformatie.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

De waarde van de vertaling in x.

dy float

De waarde van de vertaling in y.

TranslateTransform(vloat, vloat, matrixOrder)

Translateert de lokale geometrische transformatie door de aangegeven dimensies in de aangegeven volgorde.

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

Parameters

dx float

De waarde van de vertaling in x.

dy float

De waarde van de vertaling in y.

order MatrixOrder

De bestelling (prepend of append) waarin de vertaling moet worden toegepast.

 Nederlands