Class Graphics

Class Graphics

nazivni prostor: Aspose.Imaging Sastav: Aspose.Imaging.dll (25.4.0)

Predstavlja grafiku prema grafičkom motoru koji se koristi u sadašnjoj montaži.

public sealed class Graphics

Inheritance

object Graphics

naslijeđeni članovi

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

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

Inicijalizira novu primjenu Aspose.Imaging.Grafika razreda.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

Izvorna slika

Properties

Clip

Pronađite ili postavite područje klipa.

public Region Clip { get; set; }

Vrijednost nekretnina

Region

CompositingQuality

Dobivaju ili postavljaju kvalitetu kompozicije.

public CompositingQuality CompositingQuality { get; set; }

Vrijednost nekretnina

CompositingQuality

Dpix

Dostaje horizontalna rezolucija ovog Aspose.Imaging.Grafika.

public float DpiX { get; }

Vrijednost nekretnina

float

Dpija

Dobiva vertikalnu rezoluciju ovog Aspose.Imaging.Grafika.

public float DpiY { get; }

Vrijednost nekretnina

float

Image

Dobio je sliku.

public Image Image { get; }

Vrijednost nekretnina

Image

InterpolationMode

Pronađite ili postavite način interpoliranja.

public InterpolationMode InterpolationMode { get; set; }

Vrijednost nekretnina

InterpolationMode

IsInBeginUpdateCall

Dobiva vrijednost koja ukazuje na to je li grafika u stanju poziva Startupdate.

public bool IsInBeginUpdateCall { get; }

Vrijednost nekretnina

bool

PageScale

Pronađite ili postavite skala između svjetskih jedinica i stranica jedinice za ovaj Aspose.Imaging.Grafika.

public float PageScale { get; set; }

Vrijednost nekretnina

float

PageUnit

Pronađite ili postavite jedinicu mjerenja koja se koristi za koordinate stranice u ovom Aspose.Imaging.Grafika.

public GraphicsUnit PageUnit { get; set; }

Vrijednost nekretnina

GraphicsUnit

PaintableImageOptions

Dobivaju ili postavljaju opcije slike, koje se koriste za stvaranje slikovitih vektorskih slika za crtanje.

public ImageOptionsBase PaintableImageOptions { get; set; }

Vrijednost nekretnina

ImageOptionsBase

SmoothingMode

Pronađite ili postavite režim uklanjanja.

public SmoothingMode SmoothingMode { get; set; }

Vrijednost nekretnina

SmoothingMode

TextRenderingHint

Pronađite ili postavite upućivanje teksta.

public TextRenderingHint TextRenderingHint { get; set; }

Vrijednost nekretnina

TextRenderingHint

Transform

Pronađite ili postavite kopiju geometrijske transformacije svijeta za ovaj Aspose.Imaging.Grafika.

public Matrix Transform { get; set; }

Vrijednost nekretnina

Matrix

Methods

BeginUpdate()

Grafički učinci koji se primjenjuju nakon toga neće se primjenjivati odmah, umjesto toga, EndUpdate će uzrokovati primjenu svih učinaka odjednom.

public void BeginUpdate()

Remarks

Obratite pažnju na učinke nakon poziva BeginUpdate neće se primjenjivati u slučaju da EndUpdate nije pozvan.

Clear(Color)

Očistite grafiku površine pomoću određene boje.

public void Clear(Color color)

Parameters

color Color

Boja za čišćenje grafike površine.

Examples

Ovi primjeri koriste razred GraphicsPath i Grafika kako bi stvorili i manipulirali figure na površini slike. Primjer stvara novu sliku (tipa tipa Tiff), očisti površinu i povlači staze uz pomoć razreda Grafika.

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

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

Drži luk koji predstavlja dio elipa koji je određen parom koordinata, širinom i visinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil arka.

x float

X-koordinacija gornjeg lijevog ugla pravokugla koja definira elips.

y float

Y-koordinacija gornjeg lijevog ugla pravokugla koja definira elips.

width float

Širina pravokugla koja definira elips.

height float

Visina pravokugla koja definira elips.

startAngle float

Ugledi u stupnjevima mjereni satom od x-axis do početne točke arka.

sweepAngle float

Ugledi u stupnjevima mjereni su u vremenskom vijeku od startAngle’ parametara do završetka točke luk.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pijesak, RectangleF, float, float)

Drži luk koji predstavlja dio elipa koji je određen strukturom Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil arka.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja definira granice ellipsa.

startAngle float

Ugledi u stupnjevima mjereni satom od x-axis do početne točke arka.

sweepAngle float

Ugledi u stupnjevima mjereni su u vremenskom vijeku od startAngle’ parametara do završetka točke luk.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Slijedeći članakPen, int, int, int, int, int)

Drži luk koji predstavlja dio elipa koji je određen parom koordinata, širinom i visinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil arka.

x int

X-koordinacija gornjeg lijevog ugla pravokugla koja definira elips.

y int

Y-koordinacija gornjeg lijevog ugla pravokugla koja definira elips.

width int

Širina pravokugla koja definira elips.

height int

Visina pravokugla koja definira elips.

startAngle int

Ugledi u stupnjevima mjereni satom od x-axis do početne točke arka.

sweepAngle int

Ugledi u stupnjevima mjereni su u vremenskom vijeku od startAngle’ parametara do završetka točke luk.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Sljedeći članakPen, rektangle, float, float)

Drži luk koji predstavlja dio elipa koji je određen strukturom Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil arka.

rect Rectangle

Aspose.Imaging.RectangleF struktura koja definira granice ellipsa.

startAngle float

Ugledi u stupnjevima mjereni satom od x-axis do početne točke arka.

sweepAngle float

Ugledi u stupnjevima mjereni su u vremenskom vijeku od startAngle’ parametara do završetka točke luk.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Float, float, float, float, float, float, float, float, float, float)

Drži Bézier spline definiran četiri naručene para koordinata koji predstavljaju točke.

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 koji određuje boju, širinu i stil krivulje.

x1 float

X-koordinacija početne točke krivulje.

y1 float

Y-koordinacija početne točke kurve.

x2 float

X-koordinacija prve kontrolne točke krivulje.

y2 float

Y-koordinacija prvog kontrolnog točka kurve.

x3 float

X-koordinacija druge kontrolne točke krivulje.

y3 float

Y-koordinacija druge kontrolne točke kurve.

x4 float

X-koordinacija krajnje točke krivulje.

y4 float

Y-koordinacija krajnje točke kurve.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Slijedeći članakPen, PointF, PointF)

Drži Bézier spline definiran četiri Aspose.Imaging.PointF strukture.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil krivulje.

pt1 PointF

Aspose.Imaging.PointF struktura koja predstavlja početnu točku krivulje.

pt2 PointF

Aspose.Imaging.PointF struktura koja predstavlja prvu kontrolnu točku za krivulju.

pt3 PointF

Aspose.Imaging.PointF struktura koja predstavlja drugu kontrolnu točku za krivulju.

pt4 PointF

Aspose.Imaging.PointF struktura koja predstavlja krajnju točku krivulje.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Točka, točka, točka i točka)

Drži Bézier spline definiran četiri Aspose.Imaging.Point strukture.

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

Parameters

pen Pen

Aspose.Imaging.Pen struktura koja određuje boju, širinu i stil kurve.

pt1 Point

Aspose.Imaging.Točka struktura koja predstavlja početnu točku krivulje.

pt2 Point

Aspose.Imaging.Točka struktura koja predstavlja prvu kontrolnu točku za krivulju.

pt3 Point

Aspose.Imaging.Točka struktura koja predstavlja drugu kontrolnu točku za kurvicu.

pt4 Point

Aspose.Imaging.Točka struktura koja predstavlja krajnju točku krivulje.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

//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(Vrijeme, točka[])

Napravlja niz Bézier spline iz niza Aspose.Imaging.Point struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil krivulje.

points Point []

Raspored Aspose.Imaging.Točke strukture koje predstavljaju točke koje određuju krivulju.

Exceptions

ArgumentNullException

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

DrawBeziers(Sljedeći Članak PointF[])

Napravlja niz Bézier spline iz niza Aspose.Imaging.PointF struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil krivulje.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju točke koje određuju krivulju.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Sljedeći Članak PointF[])

Drži zatvorenu kardinalnu spline definiranu nizom struktura Aspose.Imaging.PointF. Ova metoda koristi podrazumevano napetost od 0,5 i W L17.FillMode.Alternate način punjenja.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Sljedeći Članak PointF[], i float)

Drži zatvorenu kardinalnu spline definiranu nizom Aspose.Imaging.PointF struktura pomoću određenog napetosti.Ova metoda koristi privremeni način ispunjavanja Wl17.FillMode.Alternate

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Vrijeme, točka[])

Drži zatvorenu kardinalnu spline definiranu nizom Aspose.Imaging.Point struktura.Ova metoda koristi podrazumevano napetost od 0,5 i W L17.FillMode.Alternate način punjenja.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Vrijeme, točka[], i float)

Drži zatvorenu kardinalnu spline definiranu nizom Aspose.Imaging.Point struktura pomoću određenog napetosti.Ova metoda koristi privremeni način ispunjavanja Wl17.FillMode.Alternate.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawCurve(Sljedeći Članak PointF[])

Drži kardinalnu spline kroz određenu rasponu struktura Aspose.Imaging.PointF. Ova metoda koristi podrazumevanu napetost od 0,5.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

Exceptions

ArgumentNullException

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

DrawCurve(Sljedeći Članak PointF[], i float)

Drži kardinalnu spline kroz određeni niz Aspose.Imaging.PointF struktura pomoću određenog napetosti.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju točke koje definiraju krivulju.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawCurve(Sljedeći Članak PointF[], int , int)

Drži kardinalnu spline putem određenog redoslijedu Aspose.Imaging.PointF struktura.Ova metoda koristi podrazumevano napetost od 0,5.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

offset int

Ostavite od prvog elementa u redoslijedu parametra točaka do početne točke u kurvama.

numberOfSegments int

Broj segmenata nakon početne točke za uključivanje u kurvicu.

Exceptions

ArgumentNullException

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

DrawCurve(Sljedeći Članak PointF[], int , int , float)

Drži kardinalnu spline kroz određeni red Aspose.Imaging.PointF struktura pomoću određenog napetosti.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

offset int

Ostavite od prvog elementa u redoslijedu parametra točaka do početne točke u kurvama.

numberOfSegments int

Broj segmenata nakon početne točke za uključivanje u kurvicu.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawCurve(Vrijeme, točka[])

Drži kardinalnu spline kroz određenu rasponu Aspose.Imaging.Point struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

//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(Vrijeme, točka[], i float)

Drži kardinalnu spline kroz određeni niz Aspose.Imaging.Point struktura pomoću određenog napetosti.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawCurve(Vrijeme, točka[], int , int , float)

Drži kardinalnu spline kroz određeni niz Aspose.Imaging.Point struktura pomoću određenog napetosti.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i visinu kurve.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

offset int

Ostavite od prvog elementa u redoslijedu parametra točaka do početne točke u kurvama.

numberOfSegments int

Broj segmenata nakon početne točke za uključivanje u kurvicu.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

DrawEllipse(Sljedeći Članak RectangleF)

Napravlja elips definiran granicom Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil elipa.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja definira granice ellipsa.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(plovidba, plovidba, plovidba, plovidba)

Drži ellipsa definiranog ograničavajućim pravokuglom koji je određen parom koordinata, visinom i širinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil elipa.

x float

X-koordinacija gornjeg lijevog ugla graničnog pravokuna koji definira elips.

y float

Y-koordinat gornjeg lijevog ugla graničnog pravokuna koji definira elips.

width float

Širina graničnog pravokuna koji definira elips.

height float

Visina graničnog pravokuna koji definira elips.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Sljedeći Članak Pen, Rectangle)

Drži elips određen granicnom strukturom Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil elipa.

rect Rectangle

WL17_.Rektangularna struktura koja definira granice ellipsa.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

Drži ellipsa definiranog ograničavajućim pravokuglom koji je određen parom koordinata, visinom i širinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil elipa.

x int

X-koordinacija gornjeg lijevog ugla graničnog pravokuna koji definira elips.

y int

Y-koordinat gornjeg lijevog ugla graničnog pravokuna koji definira elips.

width int

Širina graničnog pravokuna koji definira elips.

height int

Visina graničnog pravokuna koji definira elips.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Fotografija: PointF)

Napravite određenu Aspose.Imaging.Graphics.Image, koristeći svoju izvornu fizičku veličinu, na određenom mjestu.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

Slike koje treba izvući.

point PointF

Aspose.Imaging.PointF struktura koja predstavlja gornji levi kut izrezane slike.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Slika, plovidba i plovidba)

Napravite određenu Aspose.Imaging.Graphics.Image, koristeći svoju izvornu fizičku veličinu, na određenom mjestu.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x float

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y float

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, RectangleF)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

Slike koje treba izvući.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja određuje lokaciju i veličinu snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, Rectangle, GraphicsUnit)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectDestination Rectangle

Odredište je izravno.

graphicsUnit GraphicsUnit

Grafička jedinica je.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, RectangleF, GraphicsUnit)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectDestination RectangleF

Odredište je izravno.

graphicsUnit GraphicsUnit

Grafička jedinica je.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, Rectangle, GraphicsUnit, ImageAttributes)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectDestination Rectangle

Odredište je izravno.

graphicsUnit GraphicsUnit

Grafička jedinica je.

imageAttributes ImageAttributes

Slike imaju svojstva.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, RectangleF, GraphicsUnit, ImageAttributes)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectDestination RectangleF

Odredište pravokugla da se povuče.

graphicsUnit GraphicsUnit

Grafička jedinica je.

imageAttributes ImageAttributes

Slike imaju svojstva.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, Rectangle, GraphicsUnit)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectSource Rectangle

To je izvor pravice.

rectDestination Rectangle

U pravom smjeru.

graphicsUnit GraphicsUnit

Grafička jedinica je.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, RectangleF, RectangleF, GraphicsUnit)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectSource RectangleF

To je izvor pravice.

rectDestination RectangleF

U pravom smjeru.

graphicsUnit GraphicsUnit

Grafička jedinica je.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectSource Rectangle

To je izvor pravice.

rectDestination Rectangle

U pravom smjeru.

graphicsUnit GraphicsUnit

Grafička jedinica je.

imageAttributes ImageAttributes

Slike imaju svojstva.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

rectSource RectangleF

Izvorni rektangul.

rectDestination RectangleF

Odredište je izravno.

graphicsUnit GraphicsUnit

Grafička jedinica za korištenje.

imageAttributes ImageAttributes

Fotografija se koristi za korištenje.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, točka[])

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints Point []

Nastavak tri PointF strukture koje definiraju paralelogram.

DrawImage(Fotografija, točka[], Rektangle)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints Point []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect Rectangle

Izvorni rektangul.

DrawImage(Fotografija, točka[], Rectangle, GraphicsUnit)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints Point []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect Rectangle

Izvorni rektangul.

srcUnit GraphicsUnit

Jedinice mjerenja.

DrawImage(Fotografija, točka[], Rectangle, GraphicsUnit, Fotografije)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints Point []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect Rectangle

Izvorni rektangul.

srcUnit GraphicsUnit

Jedinice mjerenja.

imageAttributes ImageAttributes

Slike imaju svojstva.

DrawImage(Fotografija: PointF[])

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints PointF []

Nastavak tri PointF strukture koje definiraju paralelogram.

Exceptions

ArgumentNullException

slika

DrawImage(Fotografija: PointF[], RektangleF)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints PointF []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect RectangleF

Izvorni rektangul.

DrawImage(Fotografija: PointF[], RectangleF, GraphicsUnit)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints PointF []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect RectangleF

Izvorni rektangul.

srcUnit GraphicsUnit

Jedinice mjerenja.

DrawImage(Fotografija: PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Napravite određeni dio određenog image’ na određenom mjestu i s određenom veličinom.

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

Parameters

image Image

Slike koje treba izrezati.

destPoints PointF []

Nastavak tri PointF strukture koje definiraju paralelogram.

srcRect RectangleF

Izvorni rektangul.

srcUnit GraphicsUnit

Jedinice mjerenja.

imageAttributes ImageAttributes

Slike imaju svojstva.

DrawImage(Slika, float, float, float, float)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x float

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y float

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

width float

Širina snimljenog slika.

height float

Visina izrezane slike.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, točka)

Napravite određenu Aspose.Imaging.Graphics.Image, koristeći svoju izvornu fizičku veličinu, na određenom mjestu.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

Slike koje treba izvući.

point Point

Aspose.Imaging.Točka struktura koja predstavlja lokaciju gornjeg lijevog ugla snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, int, int)

Napravite određenu sliku, koristeći njezinu originalnu fizičku veličinu, na mjestu koje je odredio koordinatni par.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x int

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y int

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Fotografija, Rectangle)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Slike koje treba izvući.

rect Rectangle

Aspose.Imaging.Rectangle struktura koja određuje lokaciju i veličinu snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Slike: int, int, int, int)

Napravite određenu Aspose.Imaging.Graphics.Image na određenom mjestu i s određene veličine.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x int

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y int

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

width int

Širina snimljenog slika.

height int

Visina izrezane slike.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Fotografija, točka)

Napravite određenu sliku koristeći njezinu izvornu fizičku veličinu na određenom mjestu.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

Slike koje treba izvući.

point Point

Aspose.Imaging.Točka struktura koja određuje gornji levi kut snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Fotografija, int, int)

Napravite određenu sliku koristeći njezinu izvornu fizičku veličinu na mjestu koje je odredio koordinatni par.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x int

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y int

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Fotografija, Rectangle)

Napravite određenu sliku koristeći njezinu izvornu fizičku veličinu na određenom mjestu.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Slike koje treba izvući.

rect Rectangle

Aspose.Imaging.Rectangle koji određuje gornji-levi kut odrezane slike. X i Y svojstva rektangla određuju gorući-leviji kut.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Slike: int, int, int, int)

Napravite određenu sliku koristeći njezinu izvornu fizičku veličinu na određenom mjestu.

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

Parameters

sourceImage Image

Slike koje treba izvući.

x int

X-koordinacija gornjeg lijevog ugla snimljenog slika.

y int

Y-koordinacija gornjeg lijevog ugla snimljenog slika.

width int

Parametri se ne koriste.

height int

Parametri se ne koriste.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Fotografija, Rectangle)

Napravite određenu sliku bez skaliranja i, ako je potrebno, klipite kako bi se prilagodila određenom pravokuglu.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Slike koje treba izvući.

rect Rectangle

Aspose.Imaging.Rectangle u kojem se prikazuje slika.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Točka, točka i točka)

Napravlja liniju koja povezuje dvije Aspose.Imaging.Point strukture.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil linije.

point1 Point

Aspose.Imaging.Točka struktura koja predstavlja prvu točku za povezivanje.

point2 Point

Aspose.Imaging.Točka struktura koja predstavlja drugu točku za povezivanje.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

//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(Slijedeći Članak PointF, PointF)

Napravlja liniju koja povezuje dvije strukture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil linije.

point1 PointF

Aspose.Imaging.PointF struktura koja predstavlja prvu točku za povezivanje.

point2 PointF

Aspose.Imaging.PointF struktura koja predstavlja drugu točku za povezivanje.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Svijet, int, int, int, int)

Napravlja liniju koja povezuje dvije točke koje određuju koordinacijski parovi.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil linije.

x1 int

Koordinacija x prvog dijela.

y1 int

Koordinacija prvog točka.

x2 int

Koordinacija x u drugoj točki.

y2 int

Koordinacija u drugoj točki.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(plovidba, plovidba, plovidba, plovidba)

Napravlja liniju koja povezuje dvije točke koje određuju koordinacijski parovi.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil linije.

x1 float

Koordinacija x prvog dijela.

y1 float

Koordinacija prvog točka.

x2 float

Koordinacija x u drugoj točki.

y2 float

Koordinacija u drugoj točki.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Vrijeme, točka[])

Napravlja niz segmentova linije koji povezuju niz Aspose.Imaging.Point struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil segmenata linije.

points Point []

Raspored Aspose.Imaging.Točke strukture koje predstavljaju točke za povezivanje.

Exceptions

ArgumentNullException

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

ArgumentException

U rasponu points" sadrži manje od 2 boda.

DrawLines(Sljedeći Članak PointF[])

Napravlja niz segmentova linije koji povezuju niz Aspose.Imaging.PointF struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil segmenata linije.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju točke za povezivanje.

Exceptions

ArgumentNullException

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

ArgumentException

U rasponu points" sadrži manje od 2 boda.

DrawPath(Sljedeći Članak GraphicsPath)

Preuzimanje Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil staze.

path GraphicsPath

Aspose.Imaging.GrafikaPath za crtanje.

Examples

Ovi primjeri koriste razred GraphicsPath i Grafika kako bi stvorili i manipulirali figure na površini slike. Primjer stvara novu sliku (tipa tipa Tiff), očisti površinu i povlači staze uz pomoć razreda Grafika.

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

Drži oblik peća definiran elipsom određenom strukturom Aspose.Imaging.RectangleF i dvije radialne linije.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil kose.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja predstavlja ograničavajući pravokut koji definira elips iz kojeg dolazi slika.

startAngle float

Ugledi mjereni u stupnjevima satovidno od x-axis na prvu stranu pie oblika.

sweepAngle float

Ugledi mjereni u stupanjima u vijeku od startAngle’ parametara na drugu stranu podloga.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(plovidba, plovidba, plovidba, plovidba, plovidba)

Drži oblik pješa definiran elipsom koji je određen koordinatnim parom, širinom, visinom i dvjema radialnim linijama.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil kose.

x float

X-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi slika.

y float

Y-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi slika.

width float

Širina graničnog pravokuna koji definira elips iz kojeg dolazi slika.

height float

Visina graničnog pravokuna koji definira elips iz kojeg dolazi slika.

startAngle float

Ugledi mjereni u stupnjevima satovidno od x-axis na prvu stranu pie oblika.

sweepAngle float

Ugledi mjereni u stupanjima u vijeku od startAngle’ parametara na drugu stranu podloga.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Sljedeći članakPen, rektangle, float, float)

Drži oblik peća definiran elipsom određenom strukturom Aspose.Imaging.Rectangle i dvije radialne linije.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil kose.

rect Rectangle

WL17_.Rektangularna struktura koja predstavlja ograničavajući pravokut koji definira elips iz kojeg dolazi slika.

startAngle float

Ugledi mjereni u stupnjevima satovidno od x-axis na prvu stranu pie oblika.

sweepAngle float

Ugledi mjereni u stupanjima u vijeku od startAngle’ parametara na drugu stranu podloga.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

//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(Slijedeći članakPen, int, int, int, int, int)

Drži oblik pješa definiran elipsom koji je određen koordinatnim parom, širinom, visinom i dvjema radialnim linijama.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil kose.

x int

X-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi slika.

y int

Y-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi slika.

width int

Širina graničnog pravokuna koji definira elips iz kojeg dolazi slika.

height int

Visina graničnog pravokuna koji definira elips iz kojeg dolazi slika.

startAngle int

Ugledi mjereni u stupnjevima satovidno od x-axis na prvu stranu pie oblika.

sweepAngle int

Ugledi mjereni u stupanjima u vijeku od startAngle’ parametara na drugu stranu podloga.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Sljedeći Članak PointF[])

Napravlja poligon definiran nizom Aspose.Imaging.PointF struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil poligona.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju vertikale poligona.

Exceptions

ArgumentNullException

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

DrawPolygon(Vrijeme, točka[])

Napravlja poligon definiran nizom Aspose.Imaging.Point struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil poligona.

points Point []

Raspored Aspose.Imaging.Točke strukture koje predstavljaju vertikale poligona.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

//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(Sljedeći Članak RectangleF)

Drži pravokut koji je određen strukturom Aspose.Imaging.RectangleF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil pravokuna.

rect RectangleF

Struktura Aspose.Imaging.RectangleF koja predstavlja pravokugli za crtanje.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Sljedeći Članak Pen, Rectangle)

Drži pravokut koji je određen strukturom Aspose.Imaging.Rectangle.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil pravokuna.

rect Rectangle

Struktura Aspose.Imaging.Rectangle koja predstavlja pravokugli za crtanje.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

Drži pravokut koji je određen koordinatnim parom, širinom i visinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil pravokuna.

x float

X-koordinacija gornjeg lijevog ugla pravog ugla za crtanje.

y float

Y-koordinacija gornjeg lijevog ugla pravog ugla za trčanje.

width float

Širina pravokugla za crtanje.

height float

Visina pravokugla da se izvuče.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Svijet, int, int, int, int)

Drži pravokut koji je određen koordinatnim parom, širinom i visinom.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil pravokuna.

x int

X-koordinacija gornjeg lijevog ugla pravog ugla za crtanje.

y int

Y-koordinacija gornjeg lijevog ugla pravog ugla za trčanje.

width int

Širina rektangula za crtanje.

height int

Visina pravokugla za trčanje.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Sljedeći Članak RectangleF[])

Napravlja niz pravokugova navedenih strukturama Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil izvora pravokuna.

rects RectangleF []

Raspored Aspose.Imaging.RectangleF struktura koje predstavljaju pravokuglice za crtanje.

Exceptions

ArgumentNullException

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

DrawRectangles(Sljedeći Članak Pen, Rectangle[])

Napravlja niz pravokugova navedenih Aspose.Imaging.Rectangle struktura.

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

Parameters

pen Pen

Aspose.Imaging.Pen koji određuje boju, širinu i stil izvora pravokuna.

rects Rectangle []

Raspored Aspose.Imaging.Rectangle strukture koje predstavljaju pravokuglice za crtanje.

Examples

Ovaj primjer prikazuje stvaranje i korištenje objekata Pen. Primjer stvara novu sliku i crta Rectangles na površini slike.

//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(šipka, font, brush, float, float)

Priključite određenu tekstnu traku na određenom mjestu s specifičnim Aspose.Imaging.Brush i Wl17.Font objektima.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

x float

X-koordinacija gornjeg lijevog ugla izrezanog teksta.

y float

Y-koordinacija gornjeg lijevog ugla izrezanog teksta.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush i PointF)

Priključite određenu tekstnu traku na određenom mjestu s specifičnim Aspose.Imaging.Brush i Wl17.Font objektima.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

point PointF

Aspose.Imaging.PointF struktura koja određuje gornji levi kut izrezanog teksta.

Examples

Ovaj primjer koristi Graphics razred za stvaranje primitivnih oblika na površini slike. da bi se pokazala operacija, primjer stvara novu sliku u PNG formatu i crtati primitive oblike na području slike pomoću metoda Crtanja izloženih od strane razreda grafika

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

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

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

Priključite određenu tekstnu traku na određenom mjestu s specifičnim Aspose.Imaging.Brush i Wl17.Font objektima pomoću atributova formatacije specifikacijskog __ WL 17__ .StringFormat.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

x float

X-koordinacija gornjeg lijevog ugla izrezanog teksta.

y float

Y-koordinacija gornjeg lijevog ugla izrezanog teksta.

format StringFormat

Aspose.Imaging.StringFormat koji određuje atribute formatacije, kao što su raspon linije i usklađivanje, koji se primjenjuju na crtani tekst.

Exceptions

ArgumentNullException

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

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

Priključite određenu tekstnu traku na određenom mjestu s specifičnim Aspose.Imaging.Brush i Wl17.Font objektima pomoću atributova formatacije specifikacijskog __ WL 17__ .StringFormat.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

point PointF

Aspose.Imaging.PointF struktura koja određuje gornji levi kut izrezanog teksta.

format StringFormat

Aspose.Imaging.StringFormat koji određuje atribute formatacije, kao što su raspon linije i usklađivanje, koji se primjenjuju na crtani tekst.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, RectangleF)

Napravite određenu tekstnu traku u određenom pravokutku s navedenim predmetima Aspose.Imaging.Brush i W L17.Font.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struktura koja određuje lokaciju izvedenog teksta.

Exceptions

ArgumentNullException

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

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

Napravite određenu tekstnu traku u određenom pravokotoku s specifičnim Aspose.Imaging.Brush i W L 17.Font objektima pomoću atributova formatacije specificiranog __ WL 17 _.StringFormat.

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

Parameters

s string

Vrijeme za natjecanje.

font Font

Aspose.Imaging.Font koji definira tekstni format trake.

brush Brush

Aspose.Imaging.Brush koji određuje boju i teksturu izrezanog teksta.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struktura koja određuje lokaciju izvedenog teksta.

format StringFormat

Aspose.Imaging.StringFormat koji određuje atribute formatacije, kao što su raspon linije i usklađivanje, koji se primjenjuju na crtani tekst.

Exceptions

ArgumentNullException

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

EndUpdate()

Završetak caching grafičke operacije započeo nakon što je pozvan BeginUpdate. prethodne grafičke operacije će se primjenjivati odjednom kada se pozove ovaj način.

public void EndUpdate()

FillClosedCurve(Šljunčana, PointF[])

Popunjuje unutrašnjost zatvorene kardinalne krivulje definirane nizom struktura Aspose.Imaging.PointF. Ova metoda koristi privremeni napetost od 0,5 i W L17.FillMode.Alternate način punjenja.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Šljunčana, PointF[], Svijet FillMode)

Popunjuje unutrašnjost zatvorenog kardinalnog spline krivice definiranog nizom Aspose.Imaging.PointF struktura pomoću određenog načina popunjavanja.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

fillMode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje kako je krivulja ispunjena.

Exceptions

ArgumentNullException

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

FillClosedCurve(Šljunčana, PointF[], FillMode, plutajući)

Popunjuje unutrašnjost zatvorene kardinalne krivice definirane nizom Aspose.Imaging.PointF struktura pomoću određenog načina punjenja i napetosti.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points PointF []

Vrsta Aspose.Imaging.PointF struktura koja definira spline.

fillmode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje kako je krivulja ispunjena.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

FillClosedCurve(Šipka, točka[])

Popunjuje unutrašnjost zatvorenog kardinalnog spline krivice definiranog nizom Aspose.Imaging.Point struktura.Ova metoda koristi podrazumevano napetost od 0,5 i W L17.FillMode.Alternate način punjenja.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Šipka, točka[], Svijet FillMode)

Popunjuje unutrašnjost zatvorenog kardinalnog spline krivice definiranog nizom Aspose.Imaging.Point struktura pomoću određenog načina punjenja.Ova metoda koristi podrazumevanu napetost od 0,5.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

fillmode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje kako je krivulja ispunjena.

Exceptions

ArgumentNullException

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

FillClosedCurve(Šipka, točka[], FillMode, plutajući)

Popunjuje unutrašnjost zatvorene kardinalne krivulje definirane nizom Aspose.Imaging.Point struktura pomoću određenog načina punjenja i napetosti.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points Point []

Raspored Aspose.Imaging.Točke strukture koje definiraju spline.

fillmode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje kako je krivulja ispunjena.

tension float

Vrijednost veća od ili jednaka 0,0F koja određuje napetost kurve.

Exceptions

ArgumentNullException

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

FillEllipse(Šupljina, RectangleF)

Popunjuje unutrašnjost elipa definiranog ograničavajućim pravokuglom koji je određen strukturom Aspose.Imaging.RectangleF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja predstavlja ograničavajući pravokut koji definira elips.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Prskanje, float, float, float, float)

Popunjuje unutrašnjost elipa definiranog ograničavajućim pravokuglom koji je određen parom koordinata, širinom i visinom.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x float

X-koordinacija gornjeg lijevog ugla graničnog pravokuna koji definira elips.

y float

Y-koordinat gornjeg lijevog ugla graničnog pravokuna koji definira elips.

width float

Širina graničnog pravokuna koji definira elips.

height float

Visina graničnog pravokuna koji definira elips.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Šljunčana, Rectangle)

Popunjuje unutrašnjost elipa definiranog ograničavajućim pravokuglom koji je određen strukturom Aspose.Imaging.Rectangle.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect Rectangle

WL17_.Rektangularna struktura koja predstavlja ograničavajući pravokut koji definira elips.

Exceptions

ArgumentNullException

brush’ is null.

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

Popunjuje unutrašnjost elipa definiranog ograničavajućim pravokuglom koji je određen parom koordinata, širinom i visinom.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x int

X-koordinacija gornjeg lijevog ugla graničnog pravokuna koji definira elips.

y int

Y-koordinat gornjeg lijevog ugla graničnog pravokuna koji definira elips.

width int

Širina graničnog pravokuna koji definira elips.

height int

Visina graničnog pravokuna koji definira elips.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Šljunčana, GraphicsPath)

Puni unutrašnjost Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

path GraphicsPath

Aspose.Imaging.GrafikaPath koji predstavlja put za ispunjavanje.

Exceptions

ArgumentNullException

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

FillPie(Prskanje, rektangle, float, float)

Popunjuje unutrašnjost odjeljka koja je definirana elipsom određenom strukturom Aspose.Imaging.RectangleF i dvije radialne linije.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect Rectangle

WL17_.Rektangularna struktura koja predstavlja ograničavajući pravokut koji definira elips iz kojeg dolazi odjeljak pie.

startAngle float

Ugledi u stupnjevima mjereni na satnoj razini od x-axis na prvu stranu odjeljka.

sweepAngle float

Ugledi u stupnjevima mjereni satom od parametra startAngle’ na drugoj strani odjeljka pie.

Examples

Sljedeći primjer pokazuje kako sastaviti animiranu sliku GIF-a iz pojedinih blokova.

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

Popunjuje unutrašnjost odjeljka koja je definirana elipsom određenom strukturom Aspose.Imaging.RectangleF i dvije radialne linije.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja predstavlja ograničavajući pravokut koji definira elips iz kojeg dolazi odjeljak pie.

startAngle float

Ugledi u stupnjevima mjereni na satnoj razini od x-axis na prvu stranu odjeljka.

sweepAngle float

Ugledi u stupnjevima mjereni satom od parametra startAngle’ na drugoj strani odjeljka pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Broš, float, float, float, float, float, float)

Popunjuje unutrašnjost odjeljka koja je definirana elipsom određenom parom koordinata, širinom, visinom i dvjema radialnim linijama.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x float

X-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi odjeljak pie.

y float

Y-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi odjeljak pie.

width float

Širina graničnog pravokuna koji definira elips iz kojeg dolazi odjeljak pie.

height float

Visina graničnog pravokuna koji definira elips iz kojeg dolazi odjeljak pie.

startAngle float

Ugledi u stupnjevima mjereni na satnoj razini od x-axis na prvu stranu odjeljka.

sweepAngle float

Ugledi u stupnjevima mjereni satom od parametra startAngle’ na drugoj strani odjeljka pie.

Exceptions

ArgumentNullException

brush’ is null.

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

Popunjuje unutrašnjost odjeljka koja je definirana elipsom određenom parom koordinata, širinom, visinom i dvjema radialnim linijama.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x int

X-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi odjeljak pie.

y int

Y-koordinacija gornjeg lijevog ugla ograničavajućeg pravokuna koja definira elips iz kojeg dolazi odjeljak pie.

width int

Širina graničnog pravokuna koji definira elips iz kojeg dolazi odjeljak pie.

height int

Visina graničnog pravokuna koji definira elips iz kojeg dolazi odjeljak pie.

startAngle int

Ugledi u stupnjevima mjereni na satnoj razini od x-axis na prvu stranu odjeljka.

sweepAngle int

Ugledi u stupnjevima mjereni satom od parametra startAngle’ na drugoj strani odjeljka pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Šljunčana, PointF[])

Popunjuje unutrašnjost poligona definiranog nizom točaka određenih strukturama Aspose.Imaging.PointF i Wl17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju vertikale poligona za ispunjavanje.

Exceptions

ArgumentNullException

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

FillPolygon(Šljunčana, PointF[], Svijet FillMode)

Popunjuje unutrašnjost poligona definiranog nizom točaka određenih strukturama Aspose.Imaging.PointF koristeći određeni način popunjavanja.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points PointF []

Raspored Aspose.Imaging.PointF struktura koje predstavljaju vertikale poligona za ispunjavanje.

fillMode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje stil punjenja.

Exceptions

ArgumentNullException

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

FillPolygon(Šipka, točka[])

Popunjuje unutrašnjost poligona definiranog nizom točaka koje određuju Aspose.Imaging.Point strukture i W L17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points Point []

Raspored Aspose.Imaging.Točke strukture koje predstavljaju vertikale poligona za ispunjavanje.

Exceptions

ArgumentNullException

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

FillPolygon(Šipka, točka[], Svijet FillMode)

Popunjuje unutrašnjost poligona definiranog nizom točaka koje određuje Aspose.Imaging.Point strukture pomoću određenog načina popunjavanja.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

points Point []

Raspored Aspose.Imaging.Točke strukture koje predstavljaju vertikale poligona za ispunjavanje.

fillMode FillMode

Član Aspose.Imaging.FillMode popisa koji određuje stil punjenja.

Exceptions

ArgumentNullException

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

FillRectangle(Šljunčana, Rectangle)

Popunjuje unutrašnjost pravokugla koji je određen strukturom Aspose.Imaging.Rectangle.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect Rectangle

Aspose.Imaging.Rectangle struktura koja predstavlja pravokuglu za punjenje.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Šupljina, RectangleF)

Popunjuje unutrašnjost pravokugla koji je određen strukturom Aspose.Imaging.RectangleF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rect RectangleF

Aspose.Imaging.RectangleF struktura koja predstavlja pravokut za punjenje.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Prskanje, float, float, float, float)

Popunjuje unutrašnjost pravokugla koji je određen parom koordinata, širinom i visinom.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x float

X-koordinacija gornjeg lijevog ugla pravog ugla za ispunjavanje.

y float

Y-koordinacija gornjeg lijevog ugla pravog ugla za ispunjavanje.

width float

Širina rektangula za ispunjavanje.

height float

Visina rektangula za punjenje.

Exceptions

ArgumentNullException

brush’ is null.

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

Popunjuje unutrašnjost pravokugla koji je određen parom koordinata, širinom i visinom.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

x int

X-koordinacija gornjeg lijevog ugla pravog ugla za ispunjavanje.

y int

Y-koordinacija gornjeg lijevog ugla pravog ugla za ispunjavanje.

width int

Širina rektangula za ispunjavanje.

height int

Visina rektangula za punjenje.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Šljunčana, Rectangle[])

Popunjuje unutrašnjosti niz rektangula navedenih Aspose.Imaging.Rectangle struktura.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rects Rectangle []

Raspored Aspose.Imaging.Rectangle strukture koje predstavljaju pravokuglice za ispunjavanje.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Šupljina, RectangleF[])

Popunjuje unutrašnjosti niz rektangula određenih strukturama Aspose.Imaging.RectangleF.

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

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

rects RectangleF []

Raspored Aspose.Imaging.Rectangle strukture koje predstavljaju pravokuglice za ispunjavanje.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, područje)

Puni unutrašnjost Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush koji određuje karakteristike punjenja.

region Region

Aspose.Imaging.Regija koja predstavlja područje za ispunjavanje.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(string, font, SizeF, StringFormat)

Mjere određene tekstne trake s određenim parametrima

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

Parameters

text string

Tekst za mjerenje.

font Font

font za mjerenje.

layoutArea SizeF

To je područje layout.

stringFormat StringFormat

Format za string.

Returns

SizeF

Veličina u pixelima mjerene tekstne trake

MultiplyTransform(Matrix)

Množi Aspose.Imaging.Matrix koji predstavlja lokalnu geometrijsku transformaciju ove Wl17.Grafike od strane određenog _www.matrixa predodređivanjem specifičnog _ww.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix kojim se razmnožava geometrijska transformacija.

MultiplyTransform(Matrix i MatrixOrder)

Množi Aspose.Imaging.Matrix koji predstavlja lokalnu geometrijsku transformaciju ove Wl17.Grafike od strane određenog wl16 .matrixa u određenoj redoslijedu.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Aspose.Imaging.Matrix kojim se razmnožava geometrijska transformacija.

order MatrixOrder

Aspose.Imaging.MatrixOrder koji određuje u kojem svrhu da se udvostruči dvije matrice.

ResetTransform()

Obnavlja Aspose.Imaging.Graphics.Transformiranje imovine u identitet.

public void ResetTransform()

RotateTransform(float)

Vrti lokalnu geometrijsku transformaciju određenom količinom.Ova metoda predviđa rotaciju transformaciji.

public void RotateTransform(float angle)

Parameters

angle float

Uzimanje ugla rotacije.

RotateTransform(Sljedeći članakFloat, MatrixOrder)

Vrti lokalnu geometrijsku transformaciju određenom količinom u određenom redoslijedu.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

Uzimanje ugla rotacije.

order MatrixOrder

Aspose.Imaging.MatrixOrder koji određuje hoće li se priključiti ili preklopiti rotacijska matrica.

ScaleTransform(plovidba, plovidba)

Skali lokalnu geometrijsku transformaciju određenim količinama.Ova metoda predviđa skalajuću matricu transformaciji.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

Količina kojom se skalira transformacija u x-axis smjeru.

sy float

Količina kojom se skalira transformacija u smjeru y-axis.

ScaleTransform(plovidba, plovidba, MatrixOrder)

Skali lokalnu geometrijsku transformaciju određenim količinama u određenom redoslijedu.

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

Parameters

sx float

Količina kojom se skalira transformacija u x-axis smjeru.

sy float

Količina kojom se skalira transformacija u smjeru y-axis.

order MatrixOrder

Aspose.Imaging.MatrixOrder koji određuje hoće li se proširiti ili preponirati skalajuća matrica.

TranslateTransform(plovidba, plovidba)

Prevozi lokalnu geometrijsku transformaciju po određenim dimenzijama.Ova metoda predviđa prijevod transformaciji.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Vrijednost prijevoda u x.

dy float

Vrijednost prijevoda u i.

TranslateTransform(plovidba, plovidba, MatrixOrder)

Prevozi lokalnu geometrijsku transformaciju po određenim dimenzijama u određenom redoslijedu.

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

Parameters

dx float

Vrijednost prijevoda u x.

dy float

Vrijednost prijevoda u i.

order MatrixOrder

Porudžbina (prepend ili append) u kojoj se primjenjuje prevod.

 Hrvatski