Class Graphics

Class Graphics

Numele spaţiului: Aspose.Imaging Asamblare: Aspose.Imaging.dll (25.4.0)

Reprezintă graficele în funcție de motorul grafic utilizat în ansamblul actual.

public sealed class Graphics

Inheritance

object Graphics

Membrii moștenitori

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

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Inițializează o nouă instanță a clasei Aspose.Imaging.Graphics.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

Imaginea de sursă.

Properties

Clip

Obțineți sau stabiliți regiunea clip.

public Region Clip { get; set; }

Valoarea proprietății

Region

CompositingQuality

Obține sau stabilește calitatea de compoziție.

public CompositingQuality CompositingQuality { get; set; }

Valoarea proprietății

CompositingQuality

Dpix

Obține rezoluția orizontală a acestui Aspose.Imaging.Graphics.

public float DpiX { get; }

Valoarea proprietății

float

Dpiu

Obține rezoluția verticală a acestui Aspose.Imaging.Graphics.

public float DpiY { get; }

Valoarea proprietății

float

Image

Obțineți imaginea.

public Image Image { get; }

Valoarea proprietății

Image

InterpolationMode

Obține sau stabilește modul de interpolare.

public InterpolationMode InterpolationMode { get; set; }

Valoarea proprietății

InterpolationMode

IsInBeginUpdateCall

Obține o valoare care indică dacă graficul este în starea de apel BeginUpdate.

public bool IsInBeginUpdateCall { get; }

Valoarea proprietății

bool

PageScale

Obțineți sau stabiliți scala dintre unitățile lumii și unități de pagină pentru acest Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Valoarea proprietății

float

PageUnit

Obține sau stabilește unitatea de măsură utilizată pentru coordonatele de pagină în acest Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Valoarea proprietății

GraphicsUnit

PaintableImageOptions

Obține sau stabilește opțiuni de imagine, utilizate pentru a crea imagini de vactor pictabile pentru a trage.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valoarea proprietății

ImageOptionsBase

SmoothingMode

Obține sau stabilește modul de umiditate.

public SmoothingMode SmoothingMode { get; set; }

Valoarea proprietății

SmoothingMode

TextRenderingHint

Obține sau stabilește textul pentru a face o sugestie.

public TextRenderingHint TextRenderingHint { get; set; }

Valoarea proprietății

TextRenderingHint

Transform

Obține sau stabilește o copie a transformării geometrice a lumii pentru acest Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Valoarea proprietății

Matrix

Methods

BeginUpdate()

Efectele grafice aplicate mai târziu nu vor fi aplicate imediat, în schimb EndUpdate va provoca aplicarea tuturor efectelor la un moment dat.

public void BeginUpdate()

Remarks

Notă efectele după ce StartUpdate este chemat nu va fi aplicat în cazul în care EndUpdate nu este chemat.

Clear(Color)

Curăță suprafața grafică folosind culoarea specificată.

public void Clear(Color color)

Parameters

color Color

Culoarea pentru a clarifica suprafața grafică.

Examples

Aceste exemple folosesc clasa GraphicsPath și Clasa Grafica pentru a crea și manipula Figura pe o suprafață a imaginii. Exemplul creează o nouă imagine (de tipul Tiff), clarifică suprafata și atrage căi cu ajutorul clasei Grafics 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();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Drage un arc care reprezintă o parte a unui elips specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul arcului.

x float

Coordonatul x al colțului stâng superior al rectangului care definește ellipsa.

y float

Y-coordonatul colțului stâng-înalt al rectangului care definește ellipsa.

width float

Amploarea rectanglului care definește ellipsa.

height float

Înălțimea rectanglului care definește ellipsa.

startAngle float

Angolul în grade măsurat în mod orar de la x-axis la punctul de pornire al arcului.

sweepAngle float

Angle în grade măsurate în mod orar de la parametru startAngle’ până la sfârșitul punctului arcului.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Drage un arc care reprezintă o porție a unui elips specificat de o structură Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul arcului.

rect RectangleF

Aspose.Imaging.RectangleF structură care definește limitele ellipsei.

startAngle float

Angolul în grade măsurat în mod orar de la x-axis la punctul de pornire al arcului.

sweepAngle float

Angle în grade măsurate în mod orar de la parametru startAngle’ până la sfârșitul punctului arcului.

Exceptions

ArgumentNullException

pen’ is null

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

Drage un arc care reprezintă o parte a unui elips specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul arcului.

x int

Coordonatul x al colțului stâng superior al rectangului care definește ellipsa.

y int

Y-coordonatul colțului stâng-înalt al rectangului care definește ellipsa.

width int

Amploarea rectanglului care definește ellipsa.

height int

Înălțimea rectanglului care definește ellipsa.

startAngle int

Angolul în grade măsurat în mod orar de la x-axis la punctul de pornire al arcului.

sweepAngle int

Angle în grade măsurate în mod orar de la parametru startAngle’ până la sfârșitul punctului arcului.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, rectangle, float, float)

Drage un arc care reprezintă o porție a unui elips specificat de o structură Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul arcului.

rect Rectangle

Aspose.Imaging.RectangleF structură care definește limitele ellipsei.

startAngle float

Angolul în grade măsurat în mod orar de la x-axis la punctul de pornire al arcului.

sweepAngle float

Angle în grade măsurate în mod orar de la parametru startAngle’ până la sfârșitul punctului arcului.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Drage o linie Bézier definită de patru perechi de coordonate ordonate care reprezintă puncte.

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 care determină culoarea, lățimea și stilul curvei.

x1 float

Coordonatul x al punctului de pornire al curvei.

y1 float

Y-coordonatul punctului de pornire al curvei.

x2 float

Coordonatul x al primului punct de control al curvei.

y2 float

Y-coordonatul primului punct de control al curvei.

x3 float

Coordonatul x al celui de-al doilea punct de control al curvei.

y3 float

Y-coordonatul celui de-al doilea punct de control al curvei.

x4 float

Coordonatul x al punctului final al curvei.

y4 float

Y-coordonatul punctului final al curvei.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Punctul F, PointF, PointF, PointF)

Dispune o linie Bézier definită de patru structuri Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul curvei.

pt1 PointF

Aspose.Imaging.Structura PointF care reprezintă punctul de plecare al curvei.

pt2 PointF

Aspose.Imaging.Structura PointF care reprezintă primul punct de control al curvei.

pt3 PointF

Aspose.Imaging.Structura PointF care reprezintă cel de-al doilea punct de control al curvei.

pt4 PointF

Aspose.Imaging.Structura PointF care reprezintă punctul de încheiere al curvei.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Punctul, punctul, punctul, punctul)

Dispune o linie Bézier definită de patru structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Structura penului care determină culoarea, lățimea și stilul curvei.

pt1 Point

Aspose.Imaging.Structura punctului care reprezintă punctul de pornire al curvei.

pt2 Point

Aspose.Imaging.Structura punctului care reprezintă primul punct de control al curvei.

pt3 Point

Aspose.Imaging.Structura punctului care reprezintă cel de-al doilea punct de control al curvei.

pt4 Point

Aspose.Imaging.Structura punctului care reprezintă punctul de sfârșit al curvei.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

//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(Punctul, punctul[])

Încărcați o serie de spline Bézier dintr-o gamă de structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul curvei.

points Point []

Aria de structuri Aspose.Imaging.Pointe care reprezintă punctele care determină curba.

Exceptions

ArgumentNullException

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

DrawBeziers(Cuvânt cheie, PointF[])

Încărcați o serie de spline Bézier dintr-o gamă de structuri Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care reprezintă punctele care determină curba.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Cuvânt cheie, PointF[])

Încărcați o linie cardinală închisă definită printr-o serie de structuri Aspose.Imaging.PointF. Această metodă utilizează o tensiune predefinită de 0,5 și __ WL15_.FillMode.Alternate modul de umplere.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Cuvânt cheie, PointF[], în float)

Încărcați o linie cardinală închisă definită printr-o serie de structuri Aspose.Imaging.PointF folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Punctul, punctul[])

Încărcați o linie cardinală închisă definită printr-o serie de structuri Aspose.Imaging.Point. Această metodă utilizează o tensiune predefinită de 0.5 și __ WL15_.FillMode.Alternate modul de umplere.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Punctul, punctul[], în float)

Încărcați o linie cardinală închisă definită printr-o serie de structuri Aspose.Imaging.Point folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawCurve(Cuvânt cheie, PointF[])

Strânge o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.PointF. Această metodă utilizează o tensiune standard de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

Exceptions

ArgumentNullException

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

DrawCurve(Cuvânt cheie, PointF[], în float)

Încărcați o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.PointF folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care reprezintă punctele care definesc curba.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawCurve(Cuvânt cheie, PointF[], int , int)

Încărcați o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.PointF. Descrierea începe cu despăgubire de la începutul serii.Această metodă utilizează o tensiune standard de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

offset int

Îndepărtează de la primul element din rândul parametrului point" până la punctul de pornire din curbă.

numberOfSegments int

Numărul de segmente după punctul de pornire pentru a include în curbă.

Exceptions

ArgumentNullException

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

DrawCurve(Cuvânt cheie, PointF[], int , int , float)

Drage o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.PointF folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

offset int

Îndepărtează de la primul element din rândul parametrului point" până la punctul de pornire din curbă.

numberOfSegments int

Numărul de segmente după punctul de pornire pentru a include în curbă.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawCurve(Punctul, punctul[])

Încărcați o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

//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(Punctul, punctul[], în float)

Încărcați o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.Point folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawCurve(Punctul, punctul[], int , int , float)

Încărcați o linie cardinală printr-o serie specifică de structuri Aspose.Imaging.Point folosind o tensiune specificată.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, latitudinea și înălțimea curvei.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

offset int

Îndepărtează de la primul element din rândul parametrului point" până la punctul de pornire din curbă.

numberOfSegments int

Numărul de segmente după punctul de pornire pentru a include în curbă.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

DrawEllipse(Pădurea, RectangleF)

Eliberează o elipsă definită printr-o limită Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

WL17_.Pen care determină culoarea, lățimea și stilul elipsei.

rect RectangleF

Aspose.Imaging.RectangleF structură care definește limitele ellipsei.

Exceptions

ArgumentNullException

pen’ is null.

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

Eliberează o elipsă definită de un rectanglu de frontieră specificat de o pereche de coordonate, o înălțime și o lățime.

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

Parameters

pen Pen

WL17_.Pen care determină culoarea, lățimea și stilul elipsei.

x float

Coordonatul x al colțului stâng de sus al rectangului de legătură care definește ellipsa.

y float

Y-coordonatul colțului stâng-înalt al rectangului de legătură care definește ellipsa.

width float

Amploarea rectanglului de bord care definește ellipsa.

height float

Înălțimea rectanglului de legătură care definește ellipsa.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pânză, rectangle)

Eliberează o elipsă specificată printr-o structură limitată Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

WL17_.Pen care determină culoarea, lățimea și stilul elipsei.

rect Rectangle

WL17_.Structura rectangulară care definește limitele elipsei.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

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

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pân, int, int, int, int)

Eliberează o elipsă definită de un rectanglu de frontieră specificat de o pereche de coordonate, o înălțime și o lățime.

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

Parameters

pen Pen

WL17_.Pen care determină culoarea, lățimea și stilul elipsei.

x int

Coordonatul x al colțului stâng de sus al rectangului de legătură care definește ellipsa.

y int

Y-coordonatul colțului stâng-înalt al rectangului de legătură care definește ellipsa.

width int

Amploarea rectanglului de bord care definește ellipsa.

height int

Înălțimea rectanglului de legătură care definește ellipsa.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Etichetă: PointF)

Încărcați Aspose.Imaging.Graphics.Image specificat, folosind dimensiunea sa fizică originală, la locația specificată.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

point PointF

Aspose.Imaging.Structura PointF care reprezintă colțul din stânga superioară al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, float, float)

Încărcați Aspose.Imaging.Graphics.Image specificat, folosind dimensiunea sa fizică originală, la locația specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x float

Coordonatul x al colțului stâng de sus al imaginii desenate.

y float

Y-coordonatul colțului stâng de sus al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, RectangleF)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rect RectangleF

Aspose.Imaging.RectangleF structură care specifică locația și dimensiunea imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagini, Rectangle, GraphicsUnit)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectDestination Rectangle

Rețeaua de destinație.

graphicsUnit GraphicsUnit

Unitatea de grafică.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, RectangleF, GraphicsUnit)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectDestination RectangleF

Rețeaua de destinație.

graphicsUnit GraphicsUnit

Unitatea de grafică.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, Rectangle, GraphicsUnit, Atributele imaginii)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectDestination Rectangle

Rețeaua de destinație.

graphicsUnit GraphicsUnit

Unitatea de grafică.

imageAttributes ImageAttributes

Imaginea are atributuri.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, RectangleF, GraphicsUnit, Atributele imaginii)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectDestination RectangleF

Destinația rectangulară pentru a trage în.

graphicsUnit GraphicsUnit

Unitatea de grafică.

imageAttributes ImageAttributes

Imaginea are atributuri.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagini, rectangle, rectangle, grafică)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectSource Rectangle

Sursă de drept.

rectDestination Rectangle

Destinaţia rectă.

graphicsUnit GraphicsUnit

Unitatea de grafică.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, RectangleF, RectangleF, GraphicsUnit)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectSource RectangleF

Sursă de drept.

rectDestination RectangleF

Destinaţia rectă.

graphicsUnit GraphicsUnit

Unitatea de grafică.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, Rectangle, Rectangle, GraphicsUnit, Atributele imaginii)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectSource Rectangle

Sursă de drept.

rectDestination Rectangle

Destinaţia rectă.

graphicsUnit GraphicsUnit

Unitatea de grafică.

imageAttributes ImageAttributes

Imaginea are atributuri.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rectSource RectangleF

Sursă rectangulară.

rectDestination RectangleF

Rețeaua de destinație.

graphicsUnit GraphicsUnit

Unitatea grafică de utilizare.

imageAttributes ImageAttributes

Imaginea este atribuită utilizării.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagini, puncte[])

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints Point []

Un set de trei structuri PointF care definește un paralelogram.

DrawImage(Imagini, puncte[], în rectangle)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints Point []

Un set de trei structuri PointF care definește un paralelogram.

srcRect Rectangle

Sursă rectangulară.

DrawImage(Imagini, puncte[], Rectangle, GraphicsUnit)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints Point []

Un set de trei structuri PointF care definește un paralelogram.

srcRect Rectangle

Sursă rectangulară.

srcUnit GraphicsUnit

Unităţile de măsură.

DrawImage(Imagini, puncte[], Rectangle, GraphicsUnit, Atributele imaginii)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints Point []

Un set de trei structuri PointF care definește un paralelogram.

srcRect Rectangle

Sursă rectangulară.

srcUnit GraphicsUnit

Unităţile de măsură.

imageAttributes ImageAttributes

Imaginea are atributuri.

DrawImage(Etichetă: PointF[])

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints PointF []

Un set de trei structuri PointF care definește un paralelogram.

Exceptions

ArgumentNullException

Imaginea

DrawImage(Etichetă: PointF[], în rectangle)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints PointF []

Un set de trei structuri PointF care definește un paralelogram.

srcRect RectangleF

Sursă rectangulară.

DrawImage(Etichetă: PointF[], RectangleF, GraphicsUnit)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints PointF []

Un set de trei structuri PointF care definește un paralelogram.

srcRect RectangleF

Sursă rectangulară.

srcUnit GraphicsUnit

Unităţile de măsură.

DrawImage(Etichetă: PointF[], RectangleF, GraphicsUnit, Atributele imaginii)

Încărcați porția specificată a imaginii ’ la locația specificată și cu dimensiunea specificată.

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

Parameters

image Image

Imaginea pe care trebuie să o desenăm.

destPoints PointF []

Un set de trei structuri PointF care definește un paralelogram.

srcRect RectangleF

Sursă rectangulară.

srcUnit GraphicsUnit

Unităţile de măsură.

imageAttributes ImageAttributes

Imaginea are atributuri.

DrawImage(Imagine, float, float, float, float)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x float

Coordonatul x al colțului stâng de sus al imaginii desenate.

y float

Y-coordonatul colțului stâng de sus al imaginii desenate.

width float

Amploarea imaginii realizate.

height float

Înălțimea imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagini, puncte)

Încărcați Aspose.Imaging.Graphics.Image specificat, folosind dimensiunea sa fizică originală, la locația specificată.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

point Point

Aspose.Imaging.Structura punctului care reprezintă locația colțului superior-left al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imagini, int, int)

Încărcați imaginea specificată, folosind dimensiunea sa fizică originală, la locația specificată de o pereche de coordonate.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x int

Coordonatul x al colțului stâng de sus al imaginii desenate.

y int

Y-coordonatul colțului stâng de sus al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(imagini, rectangle)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rect Rectangle

Aspose.Imaging.Structura rectangulară care specifică locația și dimensiunea imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imaginea, int, int, int)

Încărcați Aspose.Imaging.Graphics.Image la locul specificat și cu dimensiunea specificată.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x int

Coordonatul x al colțului stâng de sus al imaginii desenate.

y int

Y-coordonatul colțului stâng de sus al imaginii desenate.

width int

Amploarea imaginii realizate.

height int

Înălțimea imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagini, puncte)

Descrie o imagine specifică folosind dimensiunea sa fizică originală într-o locație specifică.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

point Point

Aspose.Imaging.Structura punctului care specifică colțul din stânga superioară al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imagini, int, int)

Încărcați imaginea specificată folosind dimensiunea sa fizică originală la locația specificată de o pereche de coordonate.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x int

Coordonatul x al colțului stâng de sus al imaginii desenate.

y int

Y-coordonatul colțului stâng de sus al imaginii desenate.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(imagini, rectangle)

Descrie o imagine specifică folosind dimensiunea sa fizică originală într-o locație specifică.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rect Rectangle

Aspose.Imaging.Rectangle care specifică colțul din stânga superioară al imaginii desenate. Proprietățile X și Y ale rectanglului specificați colțul din partea de sus.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imaginea, int, int, int)

Descrie o imagine specifică folosind dimensiunea sa fizică originală într-o locație specifică.

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

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

x int

Coordonatul x al colțului stâng de sus al imaginii desenate.

y int

Y-coordonatul colțului stâng de sus al imaginii desenate.

width int

Parametru nu este utilizat.

height int

Parametru nu este utilizat.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(imagini, rectangle)

Încărcați imaginea specificată fără scalare și clipați-o, dacă este necesar, pentru a se potrivi în rectanglul specificat.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imaginea pe care trebuie să o desenăm.

rect Rectangle

Aspose.Imaging.Rectangul în care să deseneze imaginea.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Punctul, punctul și punctul)

Încărcați o linie care conectează două structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul liniei.

point1 Point

Aspose.Imaging.Structura punctului care reprezintă primul punct de conectare.

point2 Point

Aspose.Imaging.Structura punctului care reprezintă cel de-al doilea punct de conectare.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

//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(Punctul, punctul și punctul)

Încărcați o linie care conectează două structuri Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul liniei.

point1 PointF

Aspose.Imaging.Structura PointF care reprezintă primul punct de conectare.

point2 PointF

Aspose.Imaging.Structura PointF care reprezintă cel de-al doilea punct de conectare.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pân, int, int, int, int)

Încărcați o linie care conectează cele două puncte specificate de cuplurile de coordonate.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul liniei.

x1 int

Coordonatul X al primului punct.

y1 int

coordonate a primului punct.

x2 int

Coordonatul X al celui de-al doilea punct.

y2 int

coordonate a celui de-al doilea punct.

Exceptions

ArgumentNullException

pen’ is null.

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

Încărcați o linie care conectează cele două puncte specificate de cuplurile de coordonate.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul liniei.

x1 float

Coordonatul X al primului punct.

y1 float

coordonate a primului punct.

x2 float

Coordonatul X al celui de-al doilea punct.

y2 float

coordonate a celui de-al doilea punct.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Punctul, punctul[])

Încărcați o serie de segmente de linie care conectează o gamă de structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul segmentelor de linie.

points Point []

Un număr de structuri Aspose.Imaging.Point care reprezintă punctele de conectare.

Exceptions

ArgumentNullException

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

ArgumentException

Rata de puncte conține mai puțin de 2 puncte.

DrawLines(Cuvânt cheie, PointF[])

Încărcați o serie de segmente de linii care conectează o gamă de structuri Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul segmentelor de linie.

points PointF []

Un număr de structuri Aspose.Imaging.PointF care reprezintă punctele de conectare.

Exceptions

ArgumentNullException

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

ArgumentException

Rata de puncte conține mai puțin de 2 puncte.

DrawPath(Cuvânt cheie, grafică)

Încărcați un Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul drumului.

path GraphicsPath

Aspose.Imaging.GraphicsPath pentru a descrie.

Examples

Aceste exemple folosesc clasa GraphicsPath și Clasa Grafica pentru a crea și manipula Figura pe o suprafață a imaginii. Exemplul creează o nouă imagine (de tipul Tiff), clarifică suprafata și atrage căi cu ajutorul clasei Grafics 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)

Dispune o formă de picior definită de un elips specificat de o structură Aspose.Imaging.RectangleF și două linii radiale.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul formei piei.

rect RectangleF

Aspose.Imaging.RectangleF structură care reprezintă rectanglul de legătură care definește ellipsa din care provine forma piciorului.

startAngle float

Angolul este măsurat în grade de oră de la x-axis la prima parte a formei piei.

sweepAngle float

Anglă măsurată în grade în mod orar de la startParametruAnglă la partea cealaltă a formei piei.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Float, float, float, float, float, float, float)

Dispune o formă de picior definită de o elipsă specificată de o pereche de coordonate, o lățime, o înălțime și două linii radiale.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul formei piei.

x float

Coordonatul x al colțului din stânga superioară al rectangului de legătură care definește ellipsa din care provine forma piciorului.

y float

Y-coordonatul colțului superior-left al rectangului de legătură care definește ellipsa din care provine forma piciorului.

width float

Amploarea rectanglului de frontieră care definește elipsa din care provine forma piciorului.

height float

Înălțimea rectanglului de frontieră care definește ellipsa din care provine forma piei.

startAngle float

Angolul este măsurat în grade de oră de la x-axis la prima parte a formei piei.

sweepAngle float

Anglă măsurată în grade în mod orar de la startParametruAnglă la partea cealaltă a formei piei.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, rectangle, float, float)

Dispune o formă de picior definită de un elips specificat de o structură Aspose.Imaging.Rectangle și două linii radiale.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul formei piei.

rect Rectangle

Aspose.Imaging.Structura rectangulară care reprezintă rektangolul de legătură, care definește ellipsa din care provine forma piciorului.

startAngle float

Angolul este măsurat în grade de oră de la x-axis la prima parte a formei piei.

sweepAngle float

Anglă măsurată în grade în mod orar de la startParametruAnglă la partea cealaltă a formei piei.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Dispune o formă de picior definită de o elipsă specificată de o pereche de coordonate, o lățime, o înălțime și două linii radiale.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul formei piei.

x int

Coordonatul x al colțului din stânga superioară al rectangului de legătură care definește ellipsa din care provine forma piciorului.

y int

Y-coordonatul colțului superior-left al rectangului de legătură care definește ellipsa din care provine forma piciorului.

width int

Amploarea rectanglului de frontieră care definește elipsa din care provine forma piciorului.

height int

Înălțimea rectanglului de frontieră care definește ellipsa din care provine forma piei.

startAngle int

Angolul este măsurat în grade de oră de la x-axis la prima parte a formei piei.

sweepAngle int

Anglă măsurată în grade în mod orar de la startParametruAnglă la partea cealaltă a formei piei.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Cuvânt cheie, PointF[])

Dispune un poligon definit de o serie de structuri Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul poligonului.

points PointF []

Aria de structuri Aspose.Imaging.PointF care reprezintă verticalele poligonului.

Exceptions

ArgumentNullException

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

DrawPolygon(Punctul, punctul[])

Dispune un poligon definit de o serie de structuri Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul poligonului.

points Point []

Aria de structuri Aspose.Imaging.Pointe care reprezintă verticalele poligonului.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

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

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pădurea, RectangleF)

Strânge un rectanglu specificat de o structură Aspose.Imaging.RectangleF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen care determină culoarea, lățimea și stilul rectangularului.

rect RectangleF

O structură Aspose.Imaging.RectangleF care reprezintă rectanglul de a trage.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pânză, rectangle)

Strânge un rectanglu specificat de o structură Aspose.Imaging.Rectangle.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen care determină culoarea, lățimea și stilul rectangularului.

rect Rectangle

O structură Aspose.Imaging.Rectangle care reprezintă rectanglul de a trage.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Drage un rectanglu specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen care determină culoarea, lățimea și stilul rectangularului.

x float

Coordonatul x al colțului stâng de sus al rectanglului pentru a trage.

y float

Coordonatul y al colțului stâng de sus al rectanglului pentru a trage.

width float

Amploarea rectanglului pentru a trage.

height float

Înălțimea rectanglului pentru a trage.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pân, int, int, int, int)

Drage un rectanglu specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul rectangularului.

x int

Coordonatul x al colțului stâng de sus al rectanglului pentru a trage.

y int

Coordonatul y al colțului stâng de sus al rectanglului pentru a trage.

width int

Amploarea rectanglului pentru a trage.

height int

Înălțimea rectanglului pentru a trage.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pădurea, RectangleF[])

Dispune o serie de rectangle specificate de structurile Aspose.Imaging.RectangeleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul ecranelor rectangurilor.

rects RectangleF []

Aria de structuri Aspose.Imaging.RectangleF care reprezintă rectangurile de a trage.

Exceptions

ArgumentNullException

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

DrawRectangles(Pânză, rectangle[])

Dispune o serie de rectangle specificate de structurile Aspose.Imaging.Rectangles.

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

Parameters

pen Pen

Aspose.Imaging.Pen care determină culoarea, lățimea și stilul ecranelor rectangurilor.

rects Rectangle []

Aria de structuri Aspose.Imaging.Rectangle care reprezintă rectangurile de a trage.

Examples

Acest exemplu arată crearea și utilizarea obiectelor Pen. Exemplul creează o imagine nouă și desenează rectangle pe suprafața imaginii.

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

Încărcați șirul de text specificat în locația specificată cu obiectele specificate Aspose.Imaging.Brush și __ WL15_.Font.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

x float

Coordonatul x al colțului stâng de sus al textului desenat.

y float

Y-coordonatul colțului stâng de sus al textului desenat.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush și PointF)

Încărcați șirul de text specificat în locația specificată cu obiectele specificate Aspose.Imaging.Brush și __ WL15_.Font.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

point PointF

Aspose.Imaging.Structura PointF care specifică colțul din stânga superioară al textului desenat.

Examples

Acest exemplu utilizează clasa grafică pentru a crea forme primitive pe suprafața imaginii. Pentru a demonstra operațiunea, exemplul creează o nouă imagine în format PNG și desenează forme primitive pe superficialul imagini folosind metodele de desenare expuse de clasă grafică.

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

Încărcați stringul de text specificat în locația specificată cu Aspose.Imaging.Brush și Wl17.Font obiectele specificate folosind atributele de formatare ale specificului __ WL16__ .StringFormat.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

x float

Coordonatul x al colțului stâng de sus al textului desenat.

y float

Y-coordonatul colțului stâng de sus al textului desenat.

format StringFormat

Aspose.Imaging.StringFormat care specifică atributele de formatare, cum ar fi spațiul liniilor și alinierea, care sunt aplicate textului desenat.

Exceptions

ArgumentNullException

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

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

Încărcați stringul de text specificat în locația specificată cu Aspose.Imaging.Brush și Wl17.Font obiectele specificate folosind atributele de formatare ale specificului __ WL16__ .StringFormat.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

point PointF

Aspose.Imaging.Structura PointF care specifică colțul din stânga superioară al textului desenat.

format StringFormat

Aspose.Imaging.StringFormat care specifică atributele de formatare, cum ar fi spațiul liniilor și alinierea, care sunt aplicate textului desenat.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, RectangleF)

Strângeți șirul de text specificat în rectanglul indicat cu obiectele specificate Aspose.Imaging.Brush și WR17.Font.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structură care specifică locația textului desenat.

Exceptions

ArgumentNullException

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

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

Încărcați șirul text specificat în rectanglul specificat cu obiectele Aspose.Imaging.Brush specificate și Font folosind atributele de formare ale specificului __ WL16 .StringFormat.

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

Parameters

s string

String pentru a trage.

font Font

Aspose.Imaging.Fontul care definește formatul text al stringului.

brush Brush

Aspose.Imaging.Brush care determină culoarea și textura textului desenat.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF structură care specifică locația textului desenat.

format StringFormat

Aspose.Imaging.StringFormat care specifică atributele de formatare, cum ar fi spațiul liniilor și alinierea, care sunt aplicate textului desenat.

Exceptions

ArgumentNullException

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

EndUpdate()

Se termină caching-ul operațiunilor grafice care au început după ce BeginUpdate a fost chemat. operațiunile grafice anterioare vor fi aplicate imediat atunci când apelarea la această metodă.

public void EndUpdate()

FillClosedCurve(Călărași, PointF[])

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.PointF. Această metodă utilizează o tensiune predefinită de 0,5 și __ WL15_.FillMode.Alternate modul de umplere.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Călărași, PointF[], în FillMode)

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.PointF folosind modul de umplere specificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

fillMode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină modul în care este umplut curba.

Exceptions

ArgumentNullException

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

FillClosedCurve(Călărași, PointF[], FillMode , float)

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.PointF folosind modul de umplere specificat și tensiunea.

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

Parameters

brush Brush

A Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points PointF []

Aria de structuri Aspose.Imaging.PointF care definește spline.

fillmode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină modul în care este umplut curba.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brățară, punct[])

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.Point. Această metodă utilizează o tensiune predefinită de 0.5 și W L17.FillMode.Alternate modul de umplere.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brățară, punct[], în FillMode)

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.Point folosind modul de umplere specificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

fillmode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină modul în care este umplut curba.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brățară, punct[], FillMode , float)

Îmbunătățește interiorul unei curbe închise cardinale definite printr-o serie de structuri Aspose.Imaging.Point folosind modul de umplere specificat și tensiunea.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points Point []

Aria de structuri Aspose.Imaging.Point care definește spline.

fillmode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină modul în care este umplut curba.

tension float

Valoare mai mare sau egală cu 0.0F, care specifică tensiunea curvei.

Exceptions

ArgumentNullException

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

FillEllipse(Răspundeți, RectangleF)

Îmbunătățește interiorul unei ellipse definite de un rectanglu de legătură specificat de o structură Aspose.Imaging.RectangleF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect RectangleF

Aspose.Imaging.RectangleF structură care reprezintă rectanglul de legătură care definește ellipsa.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Flăcă, flăcă, flăcă, flăcă)

Îmbunătățește interiorul unei ellipse definite de un rectanglu de bord specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x float

Coordonatul x al colțului stâng de sus al rectangului de legătură care definește ellipsa.

y float

Y-coordonatul colțului stâng-înalt al rectangului de legătură care definește ellipsa.

width float

Amploarea rectanglului de bord care definește ellipsa.

height float

Înălțimea rectanglului de legătură care definește ellipsa.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brățară, rectangle)

Îmbunătățește interiorul unei ellipse definite de un rectanglu de bord specificat de o structură Aspose.Imaging.Rectangle.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect Rectangle

Aspose.Imaging.Structura rectangulară care reprezintă rektangolul de legătură ce definește ellipsa.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Scăderea, int, int, int)

Îmbunătățește interiorul unei ellipse definite de un rectanglu de bord specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x int

Coordonatul x al colțului stâng de sus al rectangului de legătură care definește ellipsa.

y int

Y-coordonatul colțului stâng-înalt al rectangului de legătură care definește ellipsa.

width int

Amploarea rectanglului de bord care definește ellipsa.

height int

Înălțimea rectanglului de legătură care definește ellipsa.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Grădiniță, GraphicsPath)

Împlinește interiorul unui Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

path GraphicsPath

Aspose.Imaging.GraphicsPath care reprezintă calea de a umple.

Exceptions

ArgumentNullException

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

FillPie(Rectangle, float, float)

Îmbunătățește interiorul unei secțiuni de picior definite de un elips specificat de o structură Aspose.Imaging.RectangleF și două linii radiale.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect Rectangle

Aspose.Imaging.Structura rectangulară care reprezintă rektangolul de legătură, care definește ellipsa din care provine secțiunea piei.

startAngle float

Anglu în grade măsurate în mod orar de la x-axis la prima parte a secțiunii pie.

sweepAngle float

Ange în grade măsurate în mod orar de la startParametru Ange la partea a doua a secțiunii pie.

Examples

Următorul exemplu arată cum să compuneți o imagine GIF animată de la blocuri individuale.

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

Îmbunătățește interiorul unei secțiuni de picior definite de un elips specificat de o structură Aspose.Imaging.RectangleF și două linii radiale.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect RectangleF

Aspose.Imaging.RectangleF structură care reprezintă rectanglul de legătură care definește ellipsa din care vine secțiunea piei.

startAngle float

Anglu în grade măsurate în mod orar de la x-axis la prima parte a secțiunii pie.

sweepAngle float

Ange în grade măsurate în mod orar de la startParametru Ange la partea a doua a secțiunii pie.

Exceptions

ArgumentNullException

brush’ is null.

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

Îmbunătățește interiorul unei secțiuni de picior definite de o elipsă specificată de o pereche de coordonate, o lățime, o înălțime și două linii radiale.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x float

Coordonatul x al colțului din stânga superioară al rectangului de legătură care definește ellipsa din care vine secțiunea piei.

y float

Y-coordonatul colțului superior-left al rectangului de legătură care definește ellipsa din care vine secțiunea piei.

width float

Amploarea rectanglului de frontieră care definește elipsa din care vine secțiunea piei.

height float

Înălțimea rectanglului de frontieră care definește ellipsa din care vine secțiunea piei.

startAngle float

Anglu în grade măsurate în mod orar de la x-axis la prima parte a secțiunii pie.

sweepAngle float

Ange în grade măsurate în mod orar de la startParametru Ange la partea a doua a secțiunii pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Scăderea, int, int, int, int, int, int)

Îmbunătățește interiorul unei secțiuni de picior definite de o elipsă specificată de o pereche de coordonate, o lățime, o înălțime și două linii radiale.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x int

Coordonatul x al colțului din stânga superioară al rectangului de legătură care definește ellipsa din care vine secțiunea piei.

y int

Y-coordonatul colțului superior-left al rectangului de legătură care definește ellipsa din care vine secțiunea piei.

width int

Amploarea rectanglului de frontieră care definește elipsa din care vine secțiunea piei.

height int

Înălțimea rectanglului de frontieră care definește ellipsa din care vine secțiunea piei.

startAngle int

Anglu în grade măsurate în mod orar de la x-axis la prima parte a secțiunii pie.

sweepAngle int

Ange în grade măsurate în mod orar de la startParametru Ange la partea a doua a secțiunii pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Călărași, PointF[])

Îmbunătățește interiorul unui poligon definit de o serie de puncte specificate de structurile Aspose.Imaging.PointF și Wl17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points PointF []

Aria de structuri Aspose.Imaging.PointF care reprezintă verticalele poligonului pentru a umple.

Exceptions

ArgumentNullException

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

FillPolygon(Călărași, PointF[], în FillMode)

Îmbunătățește interiorul unui poligon definit de o serie de puncte specificate de structurile Aspose.Imaging.PointF folosind modul de umplere specificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points PointF []

Aria de structuri Aspose.Imaging.PointF care reprezintă verticalele poligonului pentru a umple.

fillMode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină stilul de umplere.

Exceptions

ArgumentNullException

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

FillPolygon(Brățară, punct[])

Îmbunătățește interiorul unui poligon definit de o serie de puncte specificate de structurile de punct Aspose.Imaging.Punct și Wl17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points Point []

Aria de structuri Aspose.Imaging.Pointe care reprezintă verticalele poligonului pentru a umple.

Exceptions

ArgumentNullException

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

FillPolygon(Brățară, punct[], în FillMode)

Îmbunătățește interiorul unui poligon definit de o serie de puncte specificate de structurile Aspose.Imaging.Point folosind modul de umplere specificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

points Point []

Aria de structuri Aspose.Imaging.Pointe care reprezintă verticalele poligonului pentru a umple.

fillMode FillMode

Membru al enumerării Aspose.Imaging.FillMode care determină stilul de umplere.

Exceptions

ArgumentNullException

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

FillRectangle(Brățară, rectangle)

Îmbunătățește interiorul unui rectanglu specificat de o structură Aspose.Imaging.Rectangle.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect Rectangle

Aspose.Imaging.Structura rectangulară care reprezintă rektangolul de a umple.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Răspundeți, RectangleF)

Împlinește interiorul unui rectanglu specificat de o structură Aspose.Imaging.RectangleF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rect RectangleF

Aspose.Imaging.RectangleF structură care reprezintă rectanglul de a umple.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Flăcă, flăcă, flăcă, flăcă)

Împlinește interiorul unui rectanglu specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x float

Coordonatul x al colțului stâng de sus al rectanglului pentru a umple.

y float

Coordonatul y al colțului stâng de sus al rectanglului pentru a umple.

width float

Amploarea rectanglului pentru a umple.

height float

Înălțimea rectanglului pentru a umple.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Scăderea, int, int, int)

Împlinește interiorul unui rectanglu specificat de o pereche de coordonate, o lățime și o înălțime.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

x int

Coordonatul x al colțului stâng de sus al rectanglului pentru a umple.

y int

Coordonatul y al colțului stâng de sus al rectanglului pentru a umple.

width int

Amploarea rectanglului pentru a umple.

height int

Înălțimea rectanglului pentru a umple.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brățară, rectangle[])

Îmbunătățește interiorul unei serii de rectangle specificate de structurile Aspose.Imaging.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rects Rectangle []

Aria de structuri Aspose.Imaging.Rectangle care reprezintă rectangurile pentru a umple.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Răspundeți, RectangleF[])

Îmbunătățește interiorul unei serii de rectanguri specificate de structurile Aspose.Imaging.RectangleF.

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

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

rects RectangleF []

Aria de structuri Aspose.Imaging.Rectangle care reprezintă rectangurile pentru a umple.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Regiune)

Îmbunătățește interiorul unui Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush care determină caracteristicile umpluturii.

region Region

Aspose.Imaging.Regiune care reprezintă zona de umplere.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(string, font, SizeF, StringFormat)

Măsură stringul text specificat cu parametri specificați

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

Parameters

text string

text pentru a măsura.

font Font

fontul pentru a măsura.

layoutArea SizeF

Zona de layout.

stringFormat StringFormat

Formatul de string.

Returns

SizeF

Dimensiuni în pixeli de string text măsurat

MultiplyTransform(Matrix)

Multiplică Aspose.Imaging.Matrix, care reprezintă transformarea geometrică locală a acestei Wl17.Grafice de către specificul __ WL16_ .Matrix prin prependarea specificului _wl18..

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix prin care să se multipliceze transformarea geometrică.

MultiplyTransform(Matrix și MatrixOrder)

Multiplică Aspose.Imaging.Matrix, care reprezintă transformarea geometrică locală a acestei Wl17.Grafice de către specificați în ordinea specificată.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Aspose.Imaging.Matrix prin care să se multipliceze transformarea geometrică.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder care specifică în ce scop să se multipliceze cele două matrice.

ResetTransform()

Resetă Aspose.Imaging.Graphics.Transformă proprietatea în identitate.

public void ResetTransform()

RotateTransform(float)

Rotă transformarea geometrică locală prin cantitatea specificată.Această metodă prelungește rotația la transformare.

public void RotateTransform(float angle)

Parameters

angle float

unghiul de rotaţie.

RotateTransform(Călărași, MatrixOrder)

Rotă transformarea geometrică locală prin cantitatea specificată în ordinea specificată.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

unghiul de rotaţie.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder care specifică dacă să se extindă sau să prependă matrica de rotație.

ScaleTransform(în float, float)

Scalează transformarea geometrică locală prin cantitățile specificate.Această metodă prelungește matrica de scalare la transformare.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

Cantitatea prin care să scaleze transformarea în direcția x-axis.

sy float

Cantitatea prin care să scaleze transformarea în direcția y-axis.

ScaleTransform(în float, float, matrixOrder)

Scalează transformarea geometrică locală prin cantitățile specificate în ordinea specificată.

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

Parameters

sx float

Cantitatea prin care să scaleze transformarea în direcția x-axis.

sy float

Cantitatea prin care să scaleze transformarea în direcția y-axis.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder care specifică dacă să extindă sau să prependă matrica de scalare.

TranslateTransform(în float, float)

Traducerea transformării geometrice locale prin dimensiunile specificate.Această metodă preconizează traducerea transformării.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Valoarea traducerii în x.

dy float

Valoarea traducerii în y.

TranslateTransform(în float, float, matrixOrder)

Traducerea transformării geometrice locale prin dimensiunile specificate în ordinea specificată.

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

Parameters

dx float

Valoarea traducerii în x.

dy float

Valoarea traducerii în y.

order MatrixOrder

Ordinul (prepend sau append) în care să se aplice traducerea.

 Română