Class Graphics

Class Graphics

A név: Aspose.Imaging Összefoglaló: Aspose.Imaging.dll (25.4.0)

A grafika a jelenlegi gyűjteményben használt grafikai motor szerint jelenik meg.

public sealed class Graphics

Inheritance

object Graphics

Örökletes tagok

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

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

Kezdődik egy új példány a Aspose.Imaging.Graphics osztály.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

A forrás képe.

Properties

Clip

Kap vagy állítsa be a klip régiót.

public Region Clip { get; set; }

ingatlan értéke

Region

CompositingQuality

Megkapja vagy beállítja a kompozíciós minőséget.

public CompositingQuality CompositingQuality { get; set; }

ingatlan értéke

CompositingQuality

Dpix

Szerezze meg ezt a Aspose.Imaging.Graphics horizontális felbontását.

public float DpiX { get; }

ingatlan értéke

float

Dpii

Megkapja a függőleges felbontást a Aspose.Imaging.Graphics.

public float DpiY { get; }

ingatlan értéke

float

Image

Megkapja a képet.

public Image Image { get; }

ingatlan értéke

Image

InterpolationMode

Megkapja vagy beállítja az interpolációs módot.

public InterpolationMode InterpolationMode { get; set; }

ingatlan értéke

InterpolationMode

IsInBeginUpdateCall

Megkap egy értéket, amely jelzi, hogy a grafika a BeginUpdate hívás állapotban van-e.

public bool IsInBeginUpdateCall { get; }

ingatlan értéke

bool

PageScale

Szerezze meg vagy állítsa be a világegységek és az oldali egységek közötti skálázást erre a Aspose.Imaging.Graphics.

public float PageScale { get; set; }

ingatlan értéke

float

PageUnit

Megkapja vagy beállítja az oldal koordinátákhoz használt mérési egységet ebben a Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

ingatlan értéke

GraphicsUnit

PaintableImageOptions

Megkapja vagy beállítja a kép opciókat, amelyeket festhető vákuumképek létrehozására használnak.

public ImageOptionsBase PaintableImageOptions { get; set; }

ingatlan értéke

ImageOptionsBase

SmoothingMode

Megkapja vagy beállítja a sima módot.

public SmoothingMode SmoothingMode { get; set; }

ingatlan értéke

SmoothingMode

TextRenderingHint

Megkapja vagy beállítja a szöveg rendering utasítást.

public TextRenderingHint TextRenderingHint { get; set; }

ingatlan értéke

TextRenderingHint

Transform

Szerezzen vagy készít egy másolatot a geometriai világátalakítás erre a Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

ingatlan értéke

Matrix

Methods

BeginUpdate()

Kezdődik a következő grafikai műveletek cachingja.A később alkalmazott grafikai hatások nem alkalmazzák azonnal, ahelyett, hogy az EndUpdate az összes hatást egyszerre alkalmazza.

public void BeginUpdate()

Remarks

Kérjük, vegye figyelembe, hogy a BeginUpdate hívása után a hatások nem kerülnek alkalmazásra, ha a EndUpdate nem hívott.

Clear(Color)

Tisztítsa meg a grafikus felületet a meghatározott szín használatával.

public void Clear(Color color)

Parameters

color Color

A szín, hogy tisztítsa meg a grafika felületét.

Examples

Ezek a példák a GraphicsPath és a grafika osztály használata a képfelületén lévő számok létrehozására és manipulálására. A példa egy új képet (tiff típusú) hoz létre, tisztítja a felületet és vonzza az útvonalakat a GrafikaPat osztály segítségével.

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

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

Vág egy arcot, amely egy ellipsz egy pár koordinátával, szélességgel és magassággal meghatározott részét képezi.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust az arc.

x float

A jobb felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y float

A jobb felső sarok y-koordinátusa, amely meghatározza az ellipszát.

width float

A rektangul szélessége, amely meghatározza az ellipszát.

height float

A rektangul magassága, amely meghatározza az ellipszát.

startAngle float

A fokos szögeket az x-axis-tól az arc kiindulási pontjáig mérik.

sweepAngle float

A szög fokozatban a startAngle’ paraméterből az arc pontjának befejezéséhez mérik az órát.

Exceptions

ArgumentNullException

pen’ is null.

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

Vág egy arc, amely egy ellipsz egy Aspose.Imaging.RectangleF szerkezet által meghatározott részét képviseli.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust az arc.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely meghatározza az ellipsz határait.

startAngle float

A fokos szögeket az x-axis-tól az arc kiindulási pontjáig mérik.

sweepAngle float

A szög fokozatban a startAngle’ paraméterből az arc pontjának befejezéséhez mérik az órát.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Az int, int, int, int, int, int)

Vág egy arcot, amely egy ellipsz egy pár koordinátával, szélességgel és magassággal meghatározott részét képezi.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust az arc.

x int

A jobb felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y int

A jobb felső sarok y-koordinátusa, amely meghatározza az ellipszát.

width int

A rektangul szélessége, amely meghatározza az ellipszát.

height int

A rektangul magassága, amely meghatározza az ellipszát.

startAngle int

A fokos szögeket az x-axis-tól az arc kiindulási pontjáig mérik.

sweepAngle int

A szög fokozatban a startAngle’ paraméterből az arc pontjának befejezéséhez mérik az órát.

Exceptions

ArgumentNullException

pen’ is null.

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

Vág egy arc, amely egy ellipsz egy Aspose.Imaging.Rectangle szerkezet által meghatározott részét képviseli.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust az arc.

rect Rectangle

Aspose.Imaging.RectangleF szerkezet, amely meghatározza az ellipsz határait.

startAngle float

A fokos szögeket az x-axis-tól az arc kiindulási pontjáig mérik.

sweepAngle float

A szög fokozatban a startAngle’ paraméterből az arc pontjának befejezéséhez mérik az órát.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

A Bézier szalagot a pontokat képviselő koordináták négy megrendelt párja határozza meg.

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, amely meghatározza a színt, szélességet és stílust a curve.

x1 float

A kurva kiindulási pontjának x-koordinátusa.

y1 float

A kurva kiindulási pontjának y-koordinátusa.

x2 float

Az első vezérlőpont x-koordinátusa.

y2 float

Az y-koordinátus az első vezérlőpont a curve.

x3 float

Az x-koordinátus a curve második ellenőrzési pontja.

y3 float

Az y-koordinátus a curve második ellenőrzési pontja.

x4 float

A kurva végpontjának x-koordinátusa.

y4 float

A kurva végpontjának y-koordinátusa.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pén, PointF, PointF és PointF)

A Bézier spline-t négy Aspose.Imaging.PointF szerkezet határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a curve.

pt1 PointF

Aspose.Imaging.PointF szerkezet, amely a curve kiindulási pontját képviseli.

pt2 PointF

Aspose.Imaging.PointF szerkezet, amely a curve első ellenőrzési pontját képviseli.

pt3 PointF

Aspose.Imaging.PointF szerkezet, amely a curve második ellenőrzési pontját képviseli.

pt4 PointF

Aspose.Imaging.PointF szerkezet, amely a függöny végpontját képviseli.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pont, pont, pont és pont)

A Bézier spline-t négy Aspose.Imaging.pont szerkezet határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen szerkezet, amely meghatározza a színt, szélességet és stílust a curve.

pt1 Point

Aspose.Imaging.A pont szerkezete, amely a curve kiindulási pontját képviseli.

pt2 Point

Aspose.Imaging.A pont szerkezete, amely a curve első ellenőrzési pontját képviseli.

pt3 Point

Aspose.Imaging.A pont szerkezete, amely a curve második ellenőrzési pontját képviseli.

pt4 Point

Aspose.Imaging.A pont szerkezete, amely a curve végpontját képviseli.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

//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(Pénz, pont[])

A Bézier splines sorozatát a Aspose.Imaging.Point szerkezetek sorából húzza.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amelyek a curve meghatározó pontokat képviselik.

Exceptions

ArgumentNullException

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

DrawBeziers(Pénz, PointF[])

A Bézier splines sorozatát a Aspose.Imaging.PointF szerkezetek sorából húzza.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amelyek a curve meghatározó pontokat képviselik.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pénz, PointF[])

Ez a módszer egy zárt kardinal spline által meghatározott sor Aspose.Imaging.PointF struktúrák. Ez az eljárás használja az alapértelmezett feszültség 0.5 és Wl17.FillMode.Alternate töltés mód.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pénz, PointF[], A flotta)

A zárott kardinális spline-t a Aspose.Imaging.PointF struktúrák sorozata határozza meg egy meghatározott feszültség használatával.Ez a módszer egy alapértelmezett WR17.FillMode.Alternate töltő üzemmódot használ.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pénz, pont[])

Ez a módszer egy zárt kardinal spline által meghatározott sor Aspose.Imaging.pont szerkezetek. Ez az eljárás használja az alapértelmezett feszültség 0.5 és W L17.FillMode.Alternate töltés mód.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pénz, pont[], A flotta)

A zárott kardinális spline-t a Aspose.Imaging.Point struktúrák sorozata határozza meg egy meghatározott feszültség használatával.Ez a módszer egy alapértelmezett Wl17.FillMode.Alternate töltő üzemmódot használ.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawCurve(Pénz, PointF[])

A kardinal spline-t a Aspose.Imaging.PointF szerkezetek egy meghatározott során keresztül húzza.Ez a módszer 0.5 alapértelmezett feszültséget használ.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

Exceptions

ArgumentNullException

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

DrawCurve(Pénz, PointF[], A flotta)

A kardinális spline-t a Aspose.Imaging.PointF szerkezetek egy meghatározott feszültséggel történő sorozata révén húzza.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amelyek a curve meghatározó pontokat képviselik.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawCurve(Pénz, PointF[], Az int, int)

A kardinal spline-t a Aspose.Imaging.PointF szerkezetek egy meghatározott során keresztül húzza.A rajzolás a sor kezdetétől kezdődik.Ez a módszer a 0.5 alapértelmezett feszültséget használja.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

offset int

A pontok paraméterének sorában az első elemről a forgatókönyvíró kiindulópontjáig.

numberOfSegments int

Segmentek száma a kiindulási pont után, hogy szerepeljen a curve.

Exceptions

ArgumentNullException

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

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

A kardinal spline-t a Aspose.Imaging.PointF szerkezetek egy meghatározott feszültséggel történő sorozata útján húzza.A rajzolás a sorrend kezdetétől kezdődik.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

offset int

A pontok paraméterének sorában az első elemről a forgatókönyvíró kiindulópontjáig.

numberOfSegments int

Segmentek száma a kiindulási pont után, hogy szerepeljen a curve.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawCurve(Pénz, pont[])

A kardinal spline-t a Aspose.Imaging.Point szerkezetek egy meghatározott során keresztül húzza.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

//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(Pénz, pont[], A flotta)

A kardinális spline-t a Aspose.Imaging.Point szerkezetek egy meghatározott során keresztül húzza, az adott feszültség használatával.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawCurve(Pénz, pont[], int , int , float)

A kardinális spline-t a Aspose.Imaging.Point szerkezetek egy meghatározott során keresztül húzza, az adott feszültség használatával.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és magasságot a curve.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

offset int

A pontok paraméterének sorában az első elemről a forgatókönyvíró kiindulópontjáig.

numberOfSegments int

Segmentek száma a kiindulási pont után, hogy szerepeljen a curve.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

DrawEllipse(Pén, RectangleF)

Az ellipszát a határ Aspose.Imaging.RectangleF határozza meg.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza az ellipsz színét, szélességét és stílusát.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely meghatározza az ellipsz határait.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Szarvas, Szarvas, Szarvas, Szarvas, Szarvas)

Az ellipszát a pár koordinátával, a magassággal és a szélességgel meghatározott határszög határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza az ellipsz színét, szélességét és stílusát.

x float

A bal felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y float

A kötőszög felső bal sarkának y-koordinátusa, amely meghatározza az ellipszát.

width float

A határvonal szélessége, amely meghatározza az ellipszát.

height float

A függőleges rektangul magassága, amely meghatározza az ellipszát.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pén, Rectangle)

Vág egy ellipszát, amelyet egy határoló Aspose.Imaging.Rectangle szerkezet határoz meg.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza az ellipsz színét, szélességét és stílusát.

rect Rectangle

WL17_.Rectangle szerkezet, amely meghatározza az ellipsz határait.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

Az ellipszát a pár koordinátával, a magassággal és a szélességgel meghatározott határszög határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza az ellipsz színét, szélességét és stílusát.

x int

A bal felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y int

A kötőszög felső bal sarkának y-koordinátusa, amely meghatározza az ellipszát.

width int

A határvonal szélessége, amely meghatározza az ellipszát.

height int

A függőleges rektangul magassága, amely meghatározza az ellipszát.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Képek, PointF)

A megadott Aspose.Imaging.Graphics.Image ábrázolása az eredeti fizikai méret használatával az adott helyen történik.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

point PointF

Aspose.Imaging.PointF szerkezet, amely a rajzolt kép felső bal sarkát képviseli.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Képek, Float, Float)

A megadott Aspose.Imaging.Graphics.Image ábrázolása az eredeti fizikai méret használatával az adott helyen történik.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x float

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y float

A rajzolt kép felső bal sarkának y-koordinátusa.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Képek, RectangleF)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely meghatározza a rajzolt kép helyét és méretét.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, Rectangle, GraphicsUnit)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectDestination Rectangle

A rendeltetési rektangul.

graphicsUnit GraphicsUnit

A grafikai egység.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, RectangleF, GraphicsUnit)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectDestination RectangleF

A rendeltetési rektangul.

graphicsUnit GraphicsUnit

A grafikai egység.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, Rectangle, GraphicsUnit, ImageAttributes)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectDestination Rectangle

A rendeltetési rektangul.

graphicsUnit GraphicsUnit

A grafikai egység.

imageAttributes ImageAttributes

A kép tulajdonságai.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Képek, RectangleF, GraphicsUnit, ImageAttributes)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectDestination RectangleF

A rendeltetési rektangul be kell vonni.

graphicsUnit GraphicsUnit

A grafikai egység.

imageAttributes ImageAttributes

A kép tulajdonságai.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, Rectangle, Rectangle, Grafika)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectSource Rectangle

A rektális forrás.

rectDestination Rectangle

A végső célpont.

graphicsUnit GraphicsUnit

A grafikai egység.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, RectangleF, RectangleF, GraphicsUnit)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectSource RectangleF

A rektális forrás.

rectDestination RectangleF

A végső célpont.

graphicsUnit GraphicsUnit

A grafikai egység.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectSource Rectangle

A rektális forrás.

rectDestination Rectangle

A végső célpont.

graphicsUnit GraphicsUnit

A grafikai egység.

imageAttributes ImageAttributes

A kép tulajdonságai.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kép, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rectSource RectangleF

A forrás rektangulája.

rectDestination RectangleF

A rendeltetési rektangul.

graphicsUnit GraphicsUnit

A grafikus egység használható.

imageAttributes ImageAttributes

A képet használni kell.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kép, pont[])

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints Point []

Három PointF szerkezet, amely meghatározza a párhuzamot.

DrawImage(kép, pont[], A rectangle)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints Point []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect Rectangle

A forrás rektangulája.

DrawImage(kép, pont[], Rectangle, GraphicsUnit)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints Point []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect Rectangle

A forrás rektangulája.

srcUnit GraphicsUnit

A mérési egységek.

DrawImage(kép, pont[], Rectangle, GraphicsUnit, Képek)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints Point []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect Rectangle

A forrás rektangulája.

srcUnit GraphicsUnit

A mérési egységek.

imageAttributes ImageAttributes

A kép tulajdonságai.

DrawImage(Képek, PointF[])

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints PointF []

Három PointF szerkezet, amely meghatározza a párhuzamot.

Exceptions

ArgumentNullException

Képek

DrawImage(Képek, PointF[], RectangleF)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints PointF []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect RectangleF

A forrás rektangulája.

DrawImage(Képek, PointF[], RectangleF, GraphicsUnit)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints PointF []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect RectangleF

A forrás rektangulája.

srcUnit GraphicsUnit

A mérési egységek.

DrawImage(Képek, PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Írja be a image" megadott részét a megadott helyen és a megadott méretben.

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

Parameters

image Image

A képet rajzolni kell.

destPoints PointF []

Három PointF szerkezet, amely meghatározza a párhuzamot.

srcRect RectangleF

A forrás rektangulája.

srcUnit GraphicsUnit

A mérési egységek.

imageAttributes ImageAttributes

A kép tulajdonságai.

DrawImage(Kép, hajó, hajó, hajó, hajó)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x float

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y float

A rajzolt kép felső bal sarkának y-koordinátusa.

width float

A festett kép széles skálája.

height float

A festett kép magassága.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kép, pont)

A megadott Aspose.Imaging.Graphics.Image ábrázolása az eredeti fizikai méret használatával az adott helyen történik.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

point Point

Aspose.Imaging.A pont szerkezete, amely a rajzolt kép felső bal sarkának helyét képezi.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kép, int, int)

A megadott képet az eredeti fizikai mérete alapján a koordinátás párja által meghatározott helyen rögzíti.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x int

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y int

A rajzolt kép felső bal sarkának y-koordinátusa.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(képek, rectangle)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rect Rectangle

Aspose.Imaging.Rectangle szerkezet, amely meghatározza a rajzolt kép helyét és méretét.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kép, int, int, int, int)

Írja be a megadott Aspose.Imaging.Graphics.Image-t a meghatározott helyen és a kijelölt méretben.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x int

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y int

A rajzolt kép felső bal sarkának y-koordinátusa.

width int

A festett kép széles skálája.

height int

A festett kép magassága.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(kép, pont)

Egy meghatározott képet rögzít az eredeti fizikai méretével egy meghatározott helyen.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

point Point

Aspose.Imaging.A pont szerkezete, amely a rajzolt kép felső bal sarkát határozza meg.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(kép, int, int)

A meghatározott képet az eredeti fizikai méretével a koordinátás párja által meghatározott helyen húzza fel.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x int

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y int

A rajzolt kép felső bal sarkának y-koordinátusa.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(képek, rectangle)

Egy meghatározott képet rögzít az eredeti fizikai méretével egy meghatározott helyen.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rect Rectangle

Aspose.Imaging.Rectangle, amely az ábrázolt kép felső bal sarkát jelzi.Az X és Y tulajdonságai a jobb sarkot jelzik.A szélesség és a magasság jellemzőit figyelmen kívül hagyják.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(kép, int, int, int, int)

Egy meghatározott képet rögzít az eredeti fizikai méretével egy meghatározott helyen.

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

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

x int

Az ábrázolt kép felső bal sarkának x-koordinátusa.

y int

A rajzolt kép felső bal sarkának y-koordinátusa.

width int

A paraméter nem használható.

height int

A paraméter nem használható.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(képek, rectangle)

A kijelölt képet skálázás nélkül húzza fel, és szükség esetén a kijelölt rektangulhoz illeszkedik.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

A kép, amivel ki kell vonni.

rect Rectangle

A Aspose.Imaging.Rectangle, amelyben a képet rajzolják.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Pén, pont és pont)

Írja össze egy vonalat, amely két Aspose.Imaging.Point szerkezethez kapcsolódik.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal színét, szélességét és stílusát.

point1 Point

Aspose.Imaging.A pont szerkezete, amely a kapcsolat első pontját jelenti.

point2 Point

Aspose.Imaging.A pont szerkezete, amely a kapcsolat második pontját jelenti.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

Írja össze a két Aspose.Imaging.PointF szerkezetet összekapcsoló vonalat.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal színét, szélességét és stílusát.

point1 PointF

Aspose.Imaging.PointF szerkezet, amely a kapcsolat első pontját jelenti.

point2 PointF

Aspose.Imaging.PointF szerkezet, amely a kapcsolat második pontját jelenti.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Az int, int, int, int)

Vegyünk egy vonalat, amely összeköti a koordináták párjai által meghatározott két pontot.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal színét, szélességét és stílusát.

x1 int

Az első pont x-koordinátusa.

y1 int

Az első pont koordinátája.

x2 int

A második pont X-koordinátusa.

y2 int

A második pont j-koordinátusa

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Szarvas, Szarvas, Szarvas, Szarvas, Szarvas)

Vegyünk egy vonalat, amely összeköti a koordináták párjai által meghatározott két pontot.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal színét, szélességét és stílusát.

x1 float

Az első pont x-koordinátusa.

y1 float

Az első pont koordinátája.

x2 float

A második pont X-koordinátusa.

y2 float

A második pont j-koordinátusa

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Pénz, pont[])

A sor egy sor vonal szegmensek, amelyek összekapcsolják a Aspose.Imaging.Point szerkezetek sorát.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal szegmensek színét, szélességét és stílusát.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amelyek képviselik a csatlakoztatandó pontokat.

Exceptions

ArgumentNullException

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

ArgumentException

A pontok" sor kevesebb, mint 2 pontot tartalmaz.

DrawLines(Pénz, PointF[])

A sor egy sor vonal szegmensek, amelyek összekapcsolják a Aspose.Imaging.PointF szerkezetek sorát.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a vonal szegmensek színét, szélességét és stílusát.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amelyek képviselik a csatlakoztatandó pontokat.

Exceptions

ArgumentNullException

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

ArgumentException

A pontok" sor kevesebb, mint 2 pontot tartalmaz.

DrawPath(Pén, grafikaPath)

Írja be a Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza az út színét, szélességét és stílusát.

path GraphicsPath

Aspose.Imaging.GraphicsPath a rajzoláshoz.

Examples

Ezek a példák a GraphicsPath és a grafika osztály használata a képfelületén lévő számok létrehozására és manipulálására. A példa egy új képet (tiff típusú) hoz létre, tisztítja a felületet és vonzza az útvonalakat a GrafikaPat osztály segítségével.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

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

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

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

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

Exceptions

ArgumentNullException

pen’ is null.-or-path’ is null.

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

Rögzít egy homlok alakja, amelyet egy Aspose.Imaging.RectangleF szerkezet és két radiális vonal által meghatározott ellipszis határoz meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a pie alak.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely a kötőszöget képviseli, ami meghatározza az ellipszát, ahonnan a láb alakja származik.

startAngle float

A szög az x-axis-tól a pie alak első oldaláig órás mértékben mérhető.

sweepAngle float

A szöget a startAngle’ paraméterről a pie alak második oldalára mérik.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(hajó, hajó, hajó, hajó, hajó, hajó)

Az ellipsz által meghatározott alakot egy koordinát pár, egy szélesség, egy magasság és két radiális vonal határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a pie alak.

x float

A bal felső sarok x-koordinátusa a kötőszögben, amely meghatározza az ellipszát, ahonnan a láb alakja jön.

y float

Az y-koordinátus a bal felső sarok a kötőszög, amely meghatározza az ellipszát, amelyből a láb alakja származik.

width float

A határvonal szélessége, amely meghatározza az ellipszát, ahonnan a láb alakja származik.

height float

A határtávolság magassága, amely meghatározza az ellipszát, ahonnan a láb alakja származik.

startAngle float

A szög az x-axis-tól a pie alak első oldaláig órás mértékben mérhető.

sweepAngle float

A szöget a startAngle’ paraméterről a pie alak második oldalára mérik.

Exceptions

ArgumentNullException

pen’ is null.

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

Rögzít egy homlok alakja, amelyet egy Aspose.Imaging.Rectangle szerkezet és két radiális vonal által meghatározott ellipszis határoz meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a pie alak.

rect Rectangle

Aspose.Imaging.Rectangle szerkezet, amely képviseli a függőleges rectangelt, ami meghatározza az ellipszát, ahonnan a láb alakja származik.

startAngle float

A szög az x-axis-tól a pie alak első oldaláig órás mértékben mérhető.

sweepAngle float

A szöget a startAngle’ paraméterről a pie alak második oldalára mérik.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

Az ellipsz által meghatározott alakot egy koordinát pár, egy szélesség, egy magasság és két radiális vonal határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a pie alak.

x int

A bal felső sarok x-koordinátusa a kötőszögben, amely meghatározza az ellipszát, ahonnan a láb alakja jön.

y int

Az y-koordinátus a bal felső sarok a kötőszög, amely meghatározza az ellipszát, amelyből a láb alakja származik.

width int

A határvonal szélessége, amely meghatározza az ellipszát, ahonnan a láb alakja származik.

height int

A határtávolság magassága, amely meghatározza az ellipszát, ahonnan a láb alakja származik.

startAngle int

A szög az x-axis-tól a pie alak első oldaláig órás mértékben mérhető.

sweepAngle int

A szöget a startAngle’ paraméterről a pie alak második oldalára mérik.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pénz, PointF[])

A poligonot a Aspose.Imaging.PointF szerkezetek sorozata határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a poligon.

points PointF []

A Aspose.Imaging.PointF szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

Exceptions

ArgumentNullException

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

DrawPolygon(Pénz, pont[])

A poligonot a Aspose.Imaging.Point szerkezetek sorozata határozza meg.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a poligon.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, RectangleF)

A szerkezet egy Aspose.Imaging.RectangleF struktúrával meghatározott rektangulát mutat be.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

A Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a rektangul.

rect RectangleF

A Aspose.Imaging.RectangleF szerkezet, amely képviseli a rektangulát a rajzoláshoz.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pén, Rectangle)

A szerkezet egy Aspose.Imaging.Rectangle struktúrával meghatározott rektangulát mutat be.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

A Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a rektangul.

rect Rectangle

A Aspose.Imaging.Rectangle szerkezet, amely képviseli a rajzhoz szükséges rektangelt.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

A koordináták párja, szélessége és magassága által meghatározott egyenes sarkot húz.

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

Parameters

pen Pen

A Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a rektangul.

x float

Az x-koordinátus a felső bal sarok a rektangul, hogy húzza.

y float

Az y-koordinátus a jobb felső sarok a rektangul, hogy húzza.

width float

A rektangul szélessége a rajzoláshoz.

height float

A rektangul magassága a rajzoláshoz.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Az int, int, int, int)

A koordináták párja, szélessége és magassága által meghatározott egyenes sarkot húz.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a rektangul.

x int

Az x-koordinátus a felső bal sarok a rektangul, hogy húzza.

y int

Az y-koordinátus a jobb felső sarok a rektangul, hogy húzza.

width int

A rektangul szélessége a rajzoláshoz.

height int

A rektangul magassága a rajzoláshoz.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pén, RectangleF[])

Rögzít egy sor rektangulát, amelyet a Aspose.Imaging.RectangleF struktúrák jelentenek.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a kiindulópontok.

rects RectangleF []

A Aspose.Imaging.RectangleF szerkezetek sorozata, amelyek képviselik a rajzok rektanguláit.

Exceptions

ArgumentNullException

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

DrawRectangles(Pén, Rectangle[])

Rögzít egy sor rektangulát, amelyet a Aspose.Imaging.Rectangle struktúrák jelentenek.

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

Parameters

pen Pen

Aspose.Imaging.Pen, amely meghatározza a színt, szélességet és stílust a kiindulópontok.

rects Rectangle []

A Aspose.Imaging.Rectangle struktúrák sorozata, amelyek képviselik a rajzolt rektangulákat.

Examples

Ez a példa azt mutatja, hogyan kell létrehozni és használni a Pen tárgyakat. A pálya új képet hoz létre, és a kép felszínén rektangulákat rajzol.

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

Írja be a megadott szöveges szalagot az adott helyen a kijelölt Aspose.Imaging.Brush és WR17.Font objektumokkal.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

x float

Az x-koordinátus a vonzott szöveg felső bal sarkában.

y float

A szöveg felső bal sarkának y-koordinátusa.

Exceptions

ArgumentNullException

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

DrawString(Szalag, Font, Brush, PointF)

Írja be a megadott szöveges szalagot az adott helyen a kijelölt Aspose.Imaging.Brush és WR17.Font objektumokkal.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

point PointF

Aspose.Imaging.PointF szerkezet, amely a vonzott szöveg felső bal sarkát határozza meg.

Examples

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

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

A kijelölt szövegszalagot az adott helyre a jelölt Aspose.Imaging.Brush és Wl17.Font objektumokkal nyomja le, a megadott __ WL 17__ .StringFormat formázási tulajdonságait használva.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

x float

Az x-koordinátus a vonzott szöveg felső bal sarkában.

y float

A szöveg felső bal sarkának y-koordinátusa.

format StringFormat

Aspose.Imaging.StringFormat, amely meghatározza a formázási attribútumokat, mint például a vonal spacing és alignment, amelyek a rajzolt szövegre vonatkoznak.

Exceptions

ArgumentNullException

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

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

A kijelölt szövegszalagot az adott helyre a jelölt Aspose.Imaging.Brush és Wl17.Font objektumokkal nyomja le, a megadott __ WL 17__ .StringFormat formázási tulajdonságait használva.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

point PointF

Aspose.Imaging.PointF szerkezet, amely a vonzott szöveg felső bal sarkát határozza meg.

format StringFormat

Aspose.Imaging.StringFormat, amely meghatározza a formázási attribútumokat, mint például a vonal spacing és alignment, amelyek a rajzolt szövegre vonatkoznak.

Exceptions

ArgumentNullException

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

DrawString(szalag, Font, Brush, RectangleF)

A megadott szövegszalagot az adott rektangulban a jelzett Aspose.Imaging.Brush és WR17.Font objektumokkal húzza fel.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF szerkezet, amely meghatározza a vonzott szöveg helyét.

Exceptions

ArgumentNullException

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

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

A megadott szövegszalagot az adott rektangulban a Aspose.Imaging.Brush és a Wl17.Font objektumok segítségével a megjelölt __ WL16 _.StringFormat formázási tulajdonságaival húzza fel.

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

Parameters

s string

A vonal a rajzolás.

font Font

Aspose.Imaging.A szövegformátumot meghatározó forrás.

brush Brush

Aspose.Imaging.A szőnyeg, amely meghatározza a festett szöveg színét és szövegét.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF szerkezet, amely meghatározza a vonzott szöveg helyét.

format StringFormat

Aspose.Imaging.StringFormat, amely meghatározza a formázási attribútumokat, mint például a vonal spacing és alignment, amelyek a rajzolt szövegre vonatkoznak.

Exceptions

ArgumentNullException

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

EndUpdate()

Befejeződik a grafikai műveletek caching kezdődött után BeginUpdate hívták. Az előző grafikai műveletek alkalmazzák egyszerre, amikor hívja ezt a módszert.

public void EndUpdate()

FillClosedCurve(Szőnyeg, PointF[])

Töltse ki a zárt kardinal spline curve belsejét, amelyet a Aspose.Imaging.PointF struktúrák sorozata határoz meg. Ez a módszer a 0.5 és a W L17.FillMode.Alternate töltő üzemmód alapértelmezett feszültségét használja.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

Exceptions

ArgumentNullException

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

FillClosedCurve(Szőnyeg, PointF[], A FillMode)

Töltse ki a zárt kardinal spline curve belsejét, amelyet a Aspose.Imaging.PointF szerkezetek sorozata határoz meg a kijelölt töltő üzemmód használatával.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

fillMode FillMode

A Aspose.Imaging.FillMode felsorolásának tagja, amely meghatározza, hogy a curve hogyan tölthető ki.

Exceptions

ArgumentNullException

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

FillClosedCurve(Szőnyeg, PointF[], FillMode és Float)

Töltse ki a zárt kardinal spline curve belsejét, amelyet a Aspose.Imaging.PointF szerkezetek sorozata határoz meg a meghatározott töltőállapot és feszültség használatával.

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

Parameters

brush Brush

A Aspose.Imaging.Brush, amely meghatározza a kitöltés jellemzőit.

points PointF []

A Aspose.Imaging.PointF struktúrák sorozata, amely meghatározza a spline-t.

fillmode FillMode

A Aspose.Imaging.FillMode felsorolásának tagja, amely meghatározza, hogy a curve hogyan tölthető ki.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bruszka, pont[])

Töltse ki a zárt kardinal spline curve belső meghatározott sor Aspose.Imaging.pont szerkezetek. Ez a módszer használ egy alapértelmezett feszültséget 0.5 és W L17.FillMode.Alternate töltő üzemmód.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bruszka, pont[], A FillMode)

Töltse ki a zárt kardinal spline curve belsejét, amelyet a Aspose.Imaging.Point szerkezetek sorozata határoz meg a kijelölt töltő üzemmód használatával.Ez a módszer 0.5 alapértelmezett feszültséget használ.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

fillmode FillMode

A Aspose.Imaging.FillMode felsorolásának tagja, amely meghatározza, hogy a curve hogyan tölthető ki.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bruszka, pont[], FillMode és Float)

Töltse ki a zárt kardinal spline curve belsejét, amelyet a Aspose.Imaging.Point szerkezetek sorozata határoz meg a kijelölt töltő mód és feszültség használatával.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amely meghatározza a spline-t.

fillmode FillMode

A Aspose.Imaging.FillMode felsorolásának tagja, amely meghatározza, hogy a curve hogyan tölthető ki.

tension float

Az értéke nagyobb, vagy 0,0F-vel egyenlő, amely megjelöli a torony feszültségét.

Exceptions

ArgumentNullException

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

FillEllipse(Bruszka, RectangleF)

Töltse ki az ellipsz belsejét, amelyet egy Aspose.Imaging.RectangleF szerkezet által meghatározott határvonalas rektangul határoz meg.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely az ellipszát meghatározó kötőszöget képviseli.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(hajó, hajó, hajó, hajó, hajó)

Töltse ki az ellipsz belsejét, amelyet egy pár koordinátával, szélességgel és magassággal meghatározott határszög határoz meg.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x float

A bal felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y float

A kötőszög felső bal sarkának y-koordinátusa, amely meghatározza az ellipszát.

width float

A határvonal szélessége, amely meghatározza az ellipszát.

height float

A függőleges rektangul magassága, amely meghatározza az ellipszát.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Bruszka, Rectangle)

Töltse ki az ellipsz belsejét, amelyet egy Aspose.Imaging.Rectangle szerkezet által meghatározott függőleges rektangol határoz meg.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect Rectangle

Aspose.Imaging.Rectangle szerkezet, amely az ellipszát meghatározó határvonalat képviseli.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Felszívó, int, int, int)

Töltse ki az ellipsz belsejét, amelyet egy pár koordinátával, szélességgel és magassággal meghatározott határszög határoz meg.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x int

A bal felső sarok x-koordinátusa, amely meghatározza az ellipszát.

y int

A kötőszög felső bal sarkának y-koordinátusa, amely meghatározza az ellipszát.

width int

A határvonal szélessége, amely meghatározza az ellipszát.

height int

A függőleges rektangul magassága, amely meghatározza az ellipszát.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Gyűrű, GraphicsPath)

Töltse ki a belső egy Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

path GraphicsPath

Aspose.Imaging.GraphicsPath, amely a kitöltés útját képviseli.

Exceptions

ArgumentNullException

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

FillPie(Fúvóka, Fúvóka, Fúvóka)

Töltse ki a belső részét egy ellipsz által meghatározott Aspose.Imaging.RectangleF szerkezet és két radiális vonal.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect Rectangle

Aspose.Imaging.Rectangle szerkezet, amely képviseli a függőleges rectangelt, ami meghatározza az ellipszát, ahonnan a pie szakasz származik.

startAngle float

A fokos szögeket az x-asszonytól az első oldalig mérik.

sweepAngle float

A fokos szögeket a startAngle paraméterről a pie szakasz második oldalára mérik.

Examples

Az alábbi példa azt mutatja, hogyan lehet animált GIF képet készíteni az egyes Gif blokkokból.

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

Töltse ki a belső részét egy ellipsz által meghatározott Aspose.Imaging.RectangleF szerkezet és két radiális vonal.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely a kötőszöget képviseli, ami meghatározza az ellipszát, ahonnan a pie szekció érkezik.

startAngle float

A fokos szögeket az x-asszonytól az első oldalig mérik.

sweepAngle float

A fokos szögeket a startAngle paraméterről a pie szakasz második oldalára mérik.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(hajó, hajó, hajó, hajó, hajó, hajó)

Töltse ki a belső részét egy ellipszis által meghatározott pár koordináták, szélesség, magasság és két radiális vonal.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x float

A határvonal felső bal sarkának x-koordinátusa, amely meghatározza az ellipszát, ahonnan a lábrész származik.

y float

Az y-koordinátus a bal felső sarok a függőleges rektangul, amely meghatározza az ellipsz, amelyből a pie szakasz jön.

width float

A határszög szélessége, amely meghatározza az ellipszát, ahonnan a pie szakasz származik.

height float

A határtávolság magassága, amely meghatározza az ellipszát, ahonnan a pie szakasz származik.

startAngle float

A fokos szögeket az x-asszonytól az első oldalig mérik.

sweepAngle float

A fokos szögeket a startAngle paraméterről a pie szakasz második oldalára mérik.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Szűrő, int, int, int, int, int)

Töltse ki a belső részét egy ellipszis által meghatározott pár koordináták, szélesség, magasság és két radiális vonal.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x int

A határvonal felső bal sarkának x-koordinátusa, amely meghatározza az ellipszát, ahonnan a lábrész származik.

y int

Az y-koordinátus a bal felső sarok a függőleges rektangul, amely meghatározza az ellipsz, amelyből a pie szakasz jön.

width int

A határszög szélessége, amely meghatározza az ellipszát, ahonnan a pie szakasz származik.

height int

A határtávolság magassága, amely meghatározza az ellipszát, ahonnan a pie szakasz származik.

startAngle int

A fokos szögeket az x-asszonytól az első oldalig mérik.

sweepAngle int

A fokos szögeket a startAngle paraméterről a pie szakasz második oldalára mérik.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Szőnyeg, PointF[])

Töltse ki a poligon belsejét, amelyet a Aspose.Imaging.PointF struktúrák és a W L17.FillMode.Alternate által meghatározott pontok sorozata határoz meg.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points PointF []

A Aspose.Imaging.PointF szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

Exceptions

ArgumentNullException

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

FillPolygon(Szőnyeg, PointF[], A FillMode)

Töltse ki a poligon belsejét, amelyet a Aspose.Imaging.PointF szerkezetek által meghatározott pontok sorozata határoz meg az adott töltési mód használatával.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points PointF []

A Aspose.Imaging.PointF szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

fillMode FillMode

A Aspose.Imaging.FillMode felsorolás tagja, amely meghatározza a kitöltés stílusát.

Exceptions

ArgumentNullException

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

FillPolygon(Bruszka, pont[])

Töltse ki a poligon belsejét, amelyet a Aspose.Imaging.pont szerkezetek és a W L17.FillMode.Alternate által meghatározott pontok sorozata határoz meg.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

Exceptions

ArgumentNullException

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

FillPolygon(Bruszka, pont[], A FillMode)

Töltse ki a poligon belsejét, amelyet a Aspose.Imaging.Punkt szerkezetek által meghatározott pontok sorozata határoz meg a kijelölt töltő üzemmód használatával.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

points Point []

A Aspose.Imaging.pont szerkezetek sorozata, amelyek a poligon vertikáit képviselik.

fillMode FillMode

A Aspose.Imaging.FillMode felsorolás tagja, amely meghatározza a kitöltés stílusát.

Exceptions

ArgumentNullException

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

FillRectangle(Bruszka, Rectangle)

Töltse ki a WL17_.Rectangle szerkezet által meghatározott rektangol belső részét.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect Rectangle

Aspose.Imaging.Rectangle szerkezet, amely képviseli a betöltendő rectangelt.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Bruszka, RectangleF)

Töltse ki a WL17_.RectangleF szerkezet által meghatározott rektangul belső részét.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rect RectangleF

Aspose.Imaging.RectangleF szerkezet, amely képviseli a rektangul kitölteni.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(hajó, hajó, hajó, hajó, hajó)

Töltse ki a pár koordinátával, szélességgel és magassággal meghatározott rektangulát.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x float

Az x-koordinátus a felső bal sarok a rektangul kitölteni.

y float

Az y-koordinátus a felső bal sarok a rektangul kitölteni.

width float

A rektangul szélessége kitölteni.

height float

A rektangul magasságának kitöltése.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Felszívó, int, int, int)

Töltse ki a pár koordinátával, szélességgel és magassággal meghatározott rektangulát.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

x int

Az x-koordinátus a felső bal sarok a rektangul kitölteni.

y int

Az y-koordinátus a felső bal sarok a rektangul kitölteni.

width int

A rektangul szélessége kitölteni.

height int

A rektangul magasságának kitöltése.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Bruszka, Rectangle[])

Töltse ki a belső egy sor rektangulák által meghatározott Aspose.Imaging.Rectangle struktúrák.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rects Rectangle []

A Aspose.Imaging.Rectangle szerkezetek sorozata, amelyek képviselik a betölteni kívánt rektangulákat.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Bruszka, RectangleF[])

Töltse ki a belső egy sor rektangulák által meghatározott Aspose.Imaging.RectangleF struktúrák.

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

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

rects RectangleF []

A Aspose.Imaging.Rectangle szerkezetek sorozata, amelyek képviselik a betölteni kívánt rektangulákat.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brüsszel, régió)

Töltse ki a belső egy Aspose.Imaging.régió.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.A kitöltés jellemzőit meghatározó törölköző.

region Region

Aspose.Imaging.Az a régió, amely a kitöltendő területet képviseli.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(Szalag, Font, SizeF, StringFormat)

Mérje meg a meghatározott szövegsorozatot az előírt paraméterekkel

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

Parameters

text string

A szöveg mérhető.

font Font

A font mérésére.

layoutArea SizeF

A layout terület.

stringFormat StringFormat

A string formátum.

Returns

SizeF

Pixel méretű mérhető szövegszalag

MultiplyTransform(Matrix)

Sokszorozza a Aspose.Imaging.Matrix, amely képviseli a helyi geometriai átalakulás ezt a Wl17.Graphics a meghatározott _ WL18_ .Matrx azáltal, hogy előtérbe a kijelölt wl16 _.Matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

A Aspose.Imaging.Matrix, amellyel a geometriai átalakulás szorozható.

MultiplyTransform(Matrix és MatrixOrder)

Sokszorozza a Aspose.Imaging.Matrix, amely képviseli a helyi geometriai átalakulás a Wl17.Grafika által a megadott _ WL16_ .Matrx a meghatározott sorrendben.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

A Aspose.Imaging.Matrix, amellyel a geometriai átalakulás szorozható.

order MatrixOrder

A Aspose.Imaging.MatrixOrder, amely meghatározza, hogy melyik célból a két matrica.

ResetTransform()

Újraindítja a Aspose.Imaging.Graphics.Transform tulajdonságot az identitás.

public void ResetTransform()

RotateTransform(Flotta)

A helyi geometriai átalakítást a meghatározott mennyiséggel forgatja.Ez a módszer az átalakításhoz kötődik.

public void RotateTransform(float angle)

Parameters

angle float

A rotáció szögéből.

RotateTransform(Szállodák itt: MatrixOrder)

A helyi geometriai átalakulást a meghatározott sorrendben meghatározott mennyiséggel forgatja.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

A rotáció szögéből.

order MatrixOrder

A Aspose.Imaging.MatrixOrder, amely megjelöli, hogy a forgatási matricát kell-e bővíteni vagy előzölni.

ScaleTransform(hajó, hajó)

A helyi geometriai átalakulást a meghatározott mennyiségekkel mérjük.Ez a módszer a mérési matrixot a átalakításhoz kötődik.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

Az a mennyiség, amellyel a transzformációt az x-axis irányba kell mérni.

sy float

Az a mennyiség, amellyel a transzformációt az y-axis irányba kell mérni.

ScaleTransform(hajó, hajó, MatrixOrder)

A helyi geometriai átalakulást a meghatározott sorrendben meghatározott mennyiségekkel mérjük.

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

Parameters

sx float

Az a mennyiség, amellyel a transzformációt az x-axis irányba kell mérni.

sy float

Az a mennyiség, amellyel a transzformációt az y-axis irányba kell mérni.

order MatrixOrder

A Aspose.Imaging.MatrixOrder, amely meghatározza, hogy bővítse-e vagy prependálja a skálázási matricát.

TranslateTransform(hajó, hajó)

Fordítja a helyi geometriai átalakítást a meghatározott dimenziók szerint.Ez a módszer a fordítást a átalakításhoz kötődik.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

A fordítás értéke x.

dy float

A fordítás értéke y.

TranslateTransform(hajó, hajó, MatrixOrder)

Fordítja a helyi geometriai átalakítást a meghatározott dimenziókkal a meghatározott sorrendben.

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

Parameters

dx float

A fordítás értéke x.

dy float

A fordítás értéke y.

order MatrixOrder

A megrendelés (prepend vagy append), amelyben a fordítást kell alkalmazni.

 Magyar