Class Graphics

Class Graphics

ja nimityö: Aspose.Imaging Kokoelma: Aspose.Imaging.dll (25.4.0)

Esittelee grafiikkaa nykyisessä kokoelmassa käytetyn grafiikan moottorin mukaan.

public sealed class Graphics

Inheritance

object Graphics

Perintöjäsenet

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

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Aloitetaan uusi esimerkki Aspose.Imaging.Graphics luokasta.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

Alkuperäinen kuva on.

Properties

Clip

Saa tai asettaa klip-alue.

public Region Clip { get; set; }

Omistuksen arvo

Region

CompositingQuality

Saa tai asettaa koostumuksen laatu.

public CompositingQuality CompositingQuality { get; set; }

Omistuksen arvo

CompositingQuality

Dpix

Saat tämän Aspose.Imaging.Grafiikan horisontaalisen resoluution.

public float DpiX { get; }

Omistuksen arvo

float

Dpiä

Saat vertikaalisen resoluution tästä Aspose.Imaging.Graphics.

public float DpiY { get; }

Omistuksen arvo

float

Image

Se saa kuvan.

public Image Image { get; }

Omistuksen arvo

Image

InterpolationMode

Saat tai asetat interpolation tilan.

public InterpolationMode InterpolationMode { get; set; }

Omistuksen arvo

InterpolationMode

IsInBeginUpdateCall

Saat arvon, joka osoittaa, onko grafiikka BeginUpdate-tilauksessa.

public bool IsInBeginUpdateCall { get; }

Omistuksen arvo

bool

PageScale

Saa tai asettaa maailman yksiköiden ja sivun yksikköiden välinen mittakaava tämän Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Omistuksen arvo

float

PageUnit

Saat tai asettaa sivun koordinaatteihin käytetyn mittausyksikön tässä Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Omistuksen arvo

GraphicsUnit

PaintableImageOptions

Saa tai asettaa kuvan vaihtoehtoja, joita käytetään luomaan maalattavia tyhjiökuvia.

public ImageOptionsBase PaintableImageOptions { get; set; }

Omistuksen arvo

ImageOptionsBase

SmoothingMode

Saa tai asettaa suihkutusmuodon.

public SmoothingMode SmoothingMode { get; set; }

Omistuksen arvo

SmoothingMode

TextRenderingHint

Saa tai asettaa teksti rendering viittaus.

public TextRenderingHint TextRenderingHint { get; set; }

Omistuksen arvo

TextRenderingHint

Transform

Saat tai asettaa jäljennöksen geometrisesta maailmanmuutoksesta tämän Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Omistuksen arvo

Matrix

Methods

BeginUpdate()

Graafiset vaikutukset, joita sovelletaan myöhemmin, eivät sovelleta välittömästi, vaan EndUpdate aiheuttaa kaikkien vaikutusten soveltamisen kerralla.

public void BeginUpdate()

Remarks

Huomaa, että vaikutuksia, kun BeginUpdate kutsutaan, ei sovelleta, jos EndUpdate ei kutsuta.

Clear(Color)

Puhdistaa grafiikan pinnan käyttämällä määriteltyä väriä.

public void Clear(Color color)

Parameters

color Color

Väri puhdistaa grafiikan pinnan.

Examples

Näitä esimerkkejä käytetään GraphicsPath- ja grafiikkaklassia luomaan ja manipuloimaan Kuvan pinnalla olevia hahmoja. Esimerkki luo uuden kuvan (tiff-tyypin), puhdistaa pinnan ja vetää reittejä Grafics Path -luokan avulla.

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

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Drao arkin, joka edustaa osa ellipsiä, joka on määritelty pari koordinaatteja, leveys ja korkeus.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää arkin värin, leveyden ja tyylin.

x float

X-koordinaatti vasemman yläkulman reikiä, joka määrittelee ellipsi.

y float

Y-koordinaatti oikean kulman vasemman yläkulmasta, joka määrittelee ellipsin.

width float

Oikean kulman leveys, joka määrittelee ellipsin.

height float

Korkeus reikiä, joka määrittelee ellipsi.

startAngle float

Kynttilät asteissa mitataan kellonaikaisesti x-aksista arkin lähtökohtaan.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ parametri lopettaa kohde arkin.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Valaisee arkin, joka edustaa Aspose.Imaging.RectangleF rakenteen mukaisen ellipsin osaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää arkin värin, leveyden ja tyylin.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka määrittelee ellipsin rajat.

startAngle float

Kynttilät asteissa mitataan kellonaikaisesti x-aksista arkin lähtökohtaan.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ parametri lopettaa kohde arkin.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pieni, int, int, int, int, int, int, int)

Drao arkin, joka edustaa osa ellipsiä, joka on määritelty pari koordinaatteja, leveys ja korkeus.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää arkin värin, leveyden ja tyylin.

x int

X-koordinaatti vasemman yläkulman reikiä, joka määrittelee ellipsi.

y int

Y-koordinaatti oikean kulman vasemman yläkulmasta, joka määrittelee ellipsin.

width int

Oikean kulman leveys, joka määrittelee ellipsin.

height int

Korkeus reikiä, joka määrittelee ellipsi.

startAngle int

Kynttilät asteissa mitataan kellonaikaisesti x-aksista arkin lähtökohtaan.

sweepAngle int

Kynttilät asteissa mitataan kellotietä startAngle’ parametri lopettaa kohde arkin.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, Rectangle, float, float)

Valaisee arkin, joka edustaa osa ellipsiä, jonka Aspose.Imaging.Rectangle rakenne on määritelty.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää arkin värin, leveyden ja tyylin.

rect Rectangle

Aspose.Imaging.RectangleF rakenne, joka määrittelee ellipsin rajat.

startAngle float

Kynttilät asteissa mitataan kellonaikaisesti x-aksista arkin lähtökohtaan.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ parametri lopettaa kohde arkin.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Drao Bézier-piste, jonka määrittävät neljä koordinaattiparia, jotka edustavat pisteitä.

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, joka määrittää kurkun värin, leveyden ja tyylin.

x1 float

x-koordinaatti kurkun lähtökohdan.

y1 float

Y-koordinaatti kurkun lähtökohdan.

x2 float

X-koordinaatti kurkun ensimmäisestä ohjauspisteestä.

y2 float

Y-koordinaatti kurkun ensimmäisestä ohjauspisteestä.

x3 float

X-koordinaatti kurkun toisesta ohjauspisteestä.

y3 float

Y-koordinaatti kurkun toisesta ohjauspisteestä.

x4 float

X-koordinaatti kulman loppupisteestä.

y4 float

Y-koordinaatti kulman loppupisteestä.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pieni, PointF, PointF ja PointF)

Drao Bézier spline määritelty neljä Aspose.Imaging.PointF rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja tyylin.

pt1 PointF

Aspose.Imaging.PointF rakenne, joka edustaa kurkun lähtökohtaa.

pt2 PointF

Aspose.Imaging.PointF rakenne, joka edustaa kurkun ensimmäistä ohjauspistettä.

pt3 PointF

Aspose.Imaging.PointF rakenne, joka edustaa kurkun toisen ohjauspisteen.

pt4 PointF

Aspose.Imaging.PointF rakenne, joka edustaa kurkun loppupisteitä.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pieni, piste, piste, piste)

Drao Bézier spline määritelty neljä Aspose.Imaging.Point rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen rakenne, joka määrittää värin, leveyden ja tyylin kurkun.

pt1 Point

Aspose.Imaging.Pisteen rakenne, joka edustaa kurkun lähtökohtaa.

pt2 Point

Aspose.Imaging.Pisteen rakenne, joka edustaa kurkun ensimmäistä ohjauspistettä.

pt3 Point

Aspose.Imaging.Pisteen rakenne, joka edustaa kurkun toista ohjauspistettä.

pt4 Point

Aspose.Imaging.Pisteen rakenne, joka edustaa kurkun loppupistettä.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

//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(Paikka, piste[])

Leikkaa sarja Bézier splines joukosta Aspose.Imaging.Point rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja tyylin.

points Point []

Valikoima Aspose.Imaging.Piste rakenteita, jotka edustavat kohtaa, joka määrittää kurkun.

Exceptions

ArgumentNullException

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

DrawBeziers(Pöytä, PointF[])

Leikkaa sarja Bézier splines joukosta Aspose.Imaging.PointF rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja tyylin.

points PointF []

Valikoima Aspose.Imaging.PointF rakenteita, jotka edustavat kurkun määritteleviä pisteitä.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pöytä, PointF[])

Valitse suljettu kardinaali spline määritelty joukko Aspose.Imaging.PointF rakenteita. Tämä menetelmä käyttää oletusarvoisen jännitteen 0.5 ja W L17.FillMode.Alternate täyttää tilaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pöytä, PointF[], ja float)

Valitse suljettu kardinaalinen spline määritelty sarjan Aspose.Imaging.PointF rakenteita käyttämällä tiettyä jännitystä. Tämä menetelmä käyttää oletusarvoisen WR17.FillMode.Alternate täyttää tilaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Paikka, piste[])

Valitse suljettu kardinaali spline määritelty joukko Aspose.Imaging.Point rakenteita. Tämä menetelmä käyttää oletusarvoisen jännitteen 0.5 ja W L17.FillMode.Alternate täyttää tilaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Paikka, piste[], ja float)

Valitse suljettu kardinaalinen spline määritelty sarjan Aspose.Imaging.Point rakenteita käyttämällä tiettyä jännitystä. Tämä menetelmä käyttää oletusarvoisen WR17.FillMode.Alternate täyttää tilaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawCurve(Pöytä, PointF[])

Se vetää kardinaalin spline läpi määritellyn sarjan Aspose.Imaging.PointF rakenteita. Tämä menetelmä käyttää oletusarvoisen jännitteen 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

Exceptions

ArgumentNullException

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

DrawCurve(Pöytä, PointF[], ja float)

Laita kardinaali spline läpi määritellyn sarjan Aspose.Imaging.PointF rakenteita käyttämällä tiettyä jännitystä.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Valikoima Aspose.Imaging.PointF rakenteita, jotka edustavat kurkun määritteleviä pisteitä.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawCurve(Pöytä, PointF[], ja int, int)

Piirtää kardinaalinen rivi Aspose.Imaging.PointF -rakenteiden määritellyn sarjan kautta.Tämä menetelmä käyttää oletusarvoisen jännityksen 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

offset int

Poistetaan points’ -parametrin järjestyksessä olevasta ensimmäisestä elementistä kurssin lähtökohtaan.

numberOfSegments int

Segmenttien lukumäärä lähtökohdan jälkeen on sisällytettävä kurssille.

Exceptions

ArgumentNullException

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

DrawCurve(Pöytä, PointF[], int , int , float)

Drao kardinaali spline läpi määritellyn sarjan Aspose.Imaging.PointF rakenteita käyttämällä määritetyn jännitteen.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

offset int

Poistetaan points’ -parametrin järjestyksessä olevasta ensimmäisestä elementistä kurssin lähtökohtaan.

numberOfSegments int

Segmenttien lukumäärä lähtökohdan jälkeen on sisällytettävä kurssille.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawCurve(Paikka, piste[])

Valitse kardinaali spline läpi määritellyn sarjan Aspose.Imaging.Point rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

//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(Paikka, piste[], ja float)

Laita kardinaali spline läpi määritellyn sarjan Aspose.Imaging.Point rakenteita käyttämällä tiettyä jännitystä.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawCurve(Paikka, piste[], int , int , float)

Laita kardinaali spline läpi määritellyn sarjan Aspose.Imaging.Point rakenteita käyttämällä tiettyä jännitystä.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää kurkun värin, leveyden ja korkeuden.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

offset int

Poistetaan points’ -parametrin järjestyksessä olevasta ensimmäisestä elementistä kurssin lähtökohtaan.

numberOfSegments int

Segmenttien lukumäärä lähtökohdan jälkeen on sisällytettävä kurssille.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

DrawEllipse(Puu, RectangleF)

Valitse ellipsi määritelty rajoitus Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää ellipsin värin, leveyden ja tyylin.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka määrittelee ellipsin rajat.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pieni, laiva, laiva, laiva, laiva)

Drao ellipsi määritelty rajoittava oikea kulma määritelty pari koordinaatteja, korkeus, ja leveys.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää ellipsin värin, leveyden ja tyylin.

x float

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

y float

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

width float

Syvyys rajanylitys, joka määrittää ellipsin.

height float

Korkeus rajattu reikiä, joka määrittelee ellipsi.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Rektangle ja rektangle)

Valitse ellipsi, joka on määritelty rajoitus Aspose.Imaging.Rectangle rakenne.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää ellipsin värin, leveyden ja tyylin.

rect Rectangle

WL17_.Rectangle rakenne, joka määrittelee ellipsin rajat.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Drao ellipsi määritelty rajoittava oikea kulma määritelty pari koordinaatteja, korkeus, ja leveys.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää ellipsin värin, leveyden ja tyylin.

x int

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

y int

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

width int

Syvyys rajanylitys, joka määrittää ellipsin.

height int

Korkeus rajattu reikiä, joka määrittelee ellipsi.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Kuva ja PointF)

Valitse määritelty Aspose.Imaging.Graphics.Image, käyttämällä alkuperäistä fyysistä kokoa, määritetyssä paikassa.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

point PointF

Aspose.Imaging.PointF rakenne, joka edustaa kuvan vasemman yläkulmasta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuvia, Float ja Float)

Valitse määritelty Aspose.Imaging.Graphics.Image, käyttämällä alkuperäistä fyysistä kokoa, määritetyssä paikassa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x float

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y float

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, RectangleF)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka määrittää kuvan sijainnin ja koon.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, Rectangle, GraphicsUnit)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectDestination Rectangle

Kohde on oikea.

graphicsUnit GraphicsUnit

Graafinen yksikkö

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, RectangleF, GraphicsUnit)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectDestination RectangleF

Kohde on oikea.

graphicsUnit GraphicsUnit

Graafinen yksikkö

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, Rectangle, GraphicsUnit, ImageAttributes)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectDestination Rectangle

Kohde on oikea.

graphicsUnit GraphicsUnit

Graafinen yksikkö

imageAttributes ImageAttributes

Kuvassa on ominaisuuksia.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, RectangleF, GraphicsUnit, ImageAttributes)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectDestination RectangleF

Tavoitteen rektangli vetää sisään.

graphicsUnit GraphicsUnit

Graafinen yksikkö

imageAttributes ImageAttributes

Kuvassa on ominaisuuksia.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, Rectangle, Rectangle, GraphicsUnit)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectSource Rectangle

Se on oikea lähde.

rectDestination Rectangle

oikea kohde kohde.

graphicsUnit GraphicsUnit

Graafinen yksikkö

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, RectangleF, RectangleF, GraphicsUnit)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectSource RectangleF

Se on oikea lähde.

rectDestination RectangleF

oikea kohde kohde.

graphicsUnit GraphicsUnit

Graafinen yksikkö

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectSource Rectangle

Se on oikea lähde.

rectDestination Rectangle

oikea kohde kohde.

graphicsUnit GraphicsUnit

Graafinen yksikkö

imageAttributes ImageAttributes

Kuvassa on ominaisuuksia.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rectSource RectangleF

Alkuperäinen reaktio.

rectDestination RectangleF

Kohde on oikea.

graphicsUnit GraphicsUnit

Graafinen yksikkö käytettäväksi.

imageAttributes ImageAttributes

Kuva on ominaista käyttää.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva ja piste[])

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints Point []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

DrawImage(Kuva ja piste[], ja rektangle)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints Point []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect Rectangle

Alkuperäinen reaktio.

DrawImage(Kuva ja piste[], Rectangle, GraphicsUnit)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints Point []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect Rectangle

Alkuperäinen reaktio.

srcUnit GraphicsUnit

Mittauksen yksiköt ovat.

DrawImage(Kuva ja piste[], Rectangle, GraphicsUnit, ImageAttributes)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints Point []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect Rectangle

Alkuperäinen reaktio.

srcUnit GraphicsUnit

Mittauksen yksiköt ovat.

imageAttributes ImageAttributes

Kuvassa on ominaisuuksia.

DrawImage(Kuva ja PointF[])

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints PointF []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

Exceptions

ArgumentNullException

Kuvia

DrawImage(Kuva ja PointF[], ja RectangleF)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints PointF []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect RectangleF

Alkuperäinen reaktio.

DrawImage(Kuva ja PointF[], RectangleF, GraphicsUnit)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints PointF []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect RectangleF

Alkuperäinen reaktio.

srcUnit GraphicsUnit

Mittauksen yksiköt ovat.

DrawImage(Kuva ja PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Paina määritellyn image’ -kuvan määritellyn osan määritellyllä paikalla ja määritellyllä koolla.

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

Parameters

image Image

Kuvia on kuvata.

destPoints PointF []

Se koostuu kolmesta PointF-rakenteesta, jotka määrittelevät rinnakkaisluettelon.

srcRect RectangleF

Alkuperäinen reaktio.

srcUnit GraphicsUnit

Mittauksen yksiköt ovat.

imageAttributes ImageAttributes

Kuvassa on ominaisuuksia.

DrawImage(Kuva, laivasto, laivasto, laivasto)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x float

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y float

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

width float

Kuvan laajuus kuvaa.

height float

Kuvan korkeus kuvaa.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuva ja piste)

Valitse määritelty Aspose.Imaging.Graphics.Image, käyttämällä alkuperäistä fyysistä kokoa, määritetyssä paikassa.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

point Point

Aspose.Imaging.Pisteen rakenne, joka edustaa kuvan vasemman yläkulman sijaintia.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kuva, int, int)

Kuvaa määritelty kuva alkuperäisen fyysisen koon avulla koordinaattiparin määrittämässä paikassa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x int

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y int

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Kuvia ja rectangle)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rect Rectangle

Aspose.Imaging.Rectangle rakenne, joka määrittää kuvan sijainnin ja koon.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(kuva, int, int, int, int)

Valitse määritelty Aspose.Imaging.Graphics.Image määritetyssä paikassa ja määrätyn koon kanssa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x int

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y int

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

width int

Kuvan laajuus kuvaa.

height int

Kuvan korkeus kuvaa.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Kuva ja piste)

Kuvaa määritetty kuva käyttämällä alkuperäistä fyysistä kokoa määritellyssä paikassa.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

point Point

Aspose.Imaging.Pisteen rakenne, joka määrittää kuvan vasemman yläkulman.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(kuva, int, int)

Valitse kuvattu kuva käyttämällä alkuperäistä fyysistä kokoa koordinaattiparin määrittämässä paikassa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x int

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y int

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Kuvia ja rectangle)

Kuvaa määritetty kuva käyttämällä alkuperäistä fyysistä kokoa määritellyssä paikassa.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rect Rectangle

Aspose.Imaging.Rectangle, joka määrittää kuvan vasemman yläkulman.Rectanglen X- ja Y-ominaisuudet määrittävät vasemmiston huippun.Laajon ja korkeuden ominaisuudet sivuutetaan.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(kuva, int, int, int, int)

Kuvaa määritetty kuva käyttämällä alkuperäistä fyysistä kokoa määritellyssä paikassa.

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

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

x int

X-koordinaatti kuvan vasemman yläkulman yläkulmasta.

y int

Y-koordinaatti kuvan vasemman yläkulman yläkulmasta.

width int

Parametria ei käytetä.

height int

Parametria ei käytetä.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Kuvia ja rectangle)

Valitse määritelty kuva mittakaavuttamatta ja leikkaa se tarvittaessa mukautumaan määriteltyyn reikiin.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Kuvia joudutaan piirustamaan.

rect Rectangle

Aspose.Imaging.Rectangle jossa kuvata.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Pinta, piste ja piste)

Paina linja, joka yhdistää kaksi Aspose.Imaging.Point rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin.

point1 Point

Aspose.Imaging.Piste rakenne, joka edustaa ensimmäistä pistettä yhdistää.

point2 Point

Aspose.Imaging.Piste rakenne, joka edustaa toisen pisteen yhdistää.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Paina linja, joka yhdistää kaksi Aspose.Imaging.PointF rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin.

point1 PointF

Aspose.Imaging.PointF rakenne, joka edustaa ensimmäistä pistettä yhdistää.

point2 PointF

Aspose.Imaging.PointF rakenne, joka edustaa toisen pisteen yhdistää.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pieni, int, int, int, int)

Paina linja, joka yhdistää kaksi koordinaattiparit määrittämään kohtaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin.

x1 int

Ensimmäisen kohdan x koordinaatti.

y1 int

Ensimmäisen kohdan y-koordinaatti.

x2 int

Toisen pisteen x-koordinaatti.

y2 int

Toisen kohdan y-koordinaatti.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pieni, laiva, laiva, laiva, laiva)

Paina linja, joka yhdistää kaksi koordinaattiparit määrittämään kohtaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin.

x1 float

Ensimmäisen kohdan x koordinaatti.

y1 float

Ensimmäisen kohdan y-koordinaatti.

x2 float

Toisen pisteen x-koordinaatti.

y2 float

Toisen kohdan y-koordinaatti.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Paikka, piste[])

Ohjaa sarjan rivisegmentejä, jotka yhdistävät joukon Aspose.Imaging.Point rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin linjan segmentit.

points Point []

Aspose.Imaging.Point rakenteet, jotka edustavat pisteitä yhdistää.

Exceptions

ArgumentNullException

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

ArgumentException

pisteet’ sarja sisältää alle 2 pistettä.

DrawLines(Pöytä, PointF[])

Ohjaa sarjan rivisegmentejä, jotka yhdistävät joukon Aspose.Imaging.PointF rakenteita.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin linjan segmentit.

points PointF []

Aspose.Imaging.PointF -rakenteet, jotka edustavat yhteyspisteitä.

Exceptions

ArgumentNullException

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

ArgumentException

pisteet’ sarja sisältää alle 2 pistettä.

DrawPath(Pieni, GraphicsPath)

Valitse Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää tien värin, leveyden ja tyylin.

path GraphicsPath

WL17_.GraphicsPath kuvaa varten.

Examples

Näitä esimerkkejä käytetään GraphicsPath- ja grafiikkaklassia luomaan ja manipuloimaan Kuvan pinnalla olevia hahmoja. Esimerkki luo uuden kuvan (tiff-tyypin), puhdistaa pinnan ja vetää reittejä Grafics Path -luokan avulla.

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

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

DrawPie(Pen, RectangleF, float, float)

Käsittelee kuvan muoto, joka määritellään Aspose.Imaging.RectangleF rakenteen ja kahden radiaalisen linjan mukaisesti.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin piirin muoto.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka edustaa sidekohtaista rektangolia, jossa määritellään ellipsi, josta piirin muoto tulee.

startAngle float

Kynttilät mitataan asteikolla kellotaajuisesti x-aksista piirin muodon ensimmäiselle puolelle.

sweepAngle float

Kynttilät mitataan kellotaajuisesti startAngle’ -parametrin startAngle’ -parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Laivasto, laivasto, laivasto, laivasto, laivasto, laivasto)

Draws piirin muoto määritelty ellipsi määritelty koordinaatti parin, leveys, korkeus, ja kaksi radiaalista linjaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin piirin muoto.

x float

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piirin muoto tulee.

y float

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piirin muoto tulee.

width float

Syvyys rajanylitys, joka määrittelee ellipsin, josta piirin muoto tulee.

height float

Korkeus rajanylitys, joka määrittelee ellipsin, josta piirin muoto tulee.

startAngle float

Kynttilät mitataan asteikolla kellotaajuisesti x-aksista piirin muodon ensimmäiselle puolelle.

sweepAngle float

Kynttilät mitataan kellotaajuisesti startAngle’ -parametrin startAngle’ -parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, Rectangle, float, float)

Käsittelee kuvan muoto, joka määritellään Aspose.Imaging.Rectangle rakenteen ja kahden radiaalin linjan mukaisesti.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin piirin muoto.

rect Rectangle

Aspose.Imaging.Rectangle rakenne, joka edustaa sidekohtaista rektangolia, jossa määritellään ellipsi, josta piirin muoto tulee.

startAngle float

Kynttilät mitataan asteikolla kellotaajuisesti x-aksista piirin muodon ensimmäiselle puolelle.

sweepAngle float

Kynttilät mitataan kellotaajuisesti startAngle’ -parametrin startAngle’ -parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Draws piirin muoto määritelty ellipsi määritelty koordinaatti parin, leveys, korkeus, ja kaksi radiaalista linjaa.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää värin, leveyden ja tyylin piirin muoto.

x int

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piirin muoto tulee.

y int

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piirin muoto tulee.

width int

Syvyys rajanylitys, joka määrittelee ellipsin, josta piirin muoto tulee.

height int

Korkeus rajanylitys, joka määrittelee ellipsin, josta piirin muoto tulee.

startAngle int

Kynttilät mitataan asteikolla kellotaajuisesti x-aksista piirin muodon ensimmäiselle puolelle.

sweepAngle int

Kynttilät mitataan kellotaajuisesti startAngle’ -parametrin startAngle’ -parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin parametrin

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pöytä, PointF[])

Tarjolla on polygoni, jonka määrittelee Aspose.Imaging.PointF -rakenteiden sarja.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää polygonin värin, leveyden ja tyylin.

points PointF []

Valikoima Aspose.Imaging.PointF rakenteita, jotka edustavat polygonin vertikaaleja.

Exceptions

ArgumentNullException

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

DrawPolygon(Paikka, piste[])

Valitse polygoni, joka määritellään Aspose.Imaging.Point-rakenteiden saralla.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittää polygonin värin, leveyden ja tyylin.

points Point []

Valikoima Aspose.Imaging.Piste rakenteita, jotka edustavat vertikaaleja polygonia.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Valitse reikiä, joka on määritetty Aspose.Imaging.RectangleF rakenteella.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee reikiön väriä, leveyttä ja tyyliä.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka edustaa suorakäyttöä.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Rektangle ja rektangle)

Valitse rektangli, joka on määritelty Aspose.Imaging.Rectangle rakenne.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee reikiön väriä, leveyttä ja tyyliä.

rect Rectangle

A Aspose.Imaging.Rectangle rakenne, joka edustaa rektangli kuvaa.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Drao oikea kulma, joka on määritelty koordinaattiparin, leveyden ja korkeuden mukaan.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee reikiön väriä, leveyttä ja tyyliä.

x float

X-koordinaatti vasemman yläkulman reikiä piirrellä.

y float

Y-koordinaatti vasemman yläkulman reikiä vetää.

width float

Oikean kulman leveys kuvaa.

height float

Korkeus reikiä piirrettyä.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pieni, int, int, int, int)

Drao oikea kulma, joka on määritelty koordinaattiparin, leveyden ja korkeuden mukaan.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee oikeakylän väriä, leveyttä ja tyyliä.

x int

X-koordinaatti vasemman yläkulman reikiä piirrellä.

y int

Y-koordinaatti vasemman yläkulman reikiä vetää.

width int

Oikean reunan laajuus kuvaa.

height int

Korkeus reikiä piirrettyä.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Puu, RectangleF[])

Tarjoaa Aspose.Imaging.RectangleF rakenteissa määriteltyjen rektanglien sarja.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee reikiä koskevien ulottuvuuksien väriä, leveyttä ja tyyliä.

rects RectangleF []

Aspose.Imaging.RectangleF rakenteiden sarja, jotka edustavat piirrettyjä oikea-osaisia.

Exceptions

ArgumentNullException

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

DrawRectangles(Rektangle ja rektangle[])

Tarjolla on sarja rektangleja, jotka on määritelty Aspose.Imaging.Rectanglen rakenteilla.

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

Parameters

pen Pen

Aspose.Imaging.Pen, joka määrittelee reikiä koskevien ulottuvuuksien väriä, leveyttä ja tyyliä.

rects Rectangle []

Aspose.Imaging.Rectangle rakenteet, jotka edustavat rectangles kuvaa.

Examples

Tämä esimerkki osoittaa Pen-objektien luomisen ja käytön. Esimerkkinä luodaan uusi Kuva ja piirrätään kuvan pinnalla Rectangles.

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

Valitse määritellyn tekstiradan määritetyllä sijainnilla Aspose.Imaging.Brush- ja WR17.Font-objektien avulla.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

x float

x-koordinaatti vasemman yläkulman piirretyn tekstin.

y float

Y-koordinaatti vasemman yläkulman piirretty teksti.

Exceptions

ArgumentNullException

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

DrawString(Tyyny, Font, Brush, PointF)

Valitse määritellyn tekstiradan määritetyllä sijainnilla Aspose.Imaging.Brush- ja WR17.Font-objektien avulla.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

point PointF

Aspose.Imaging.PointF-rakenne, joka määrittää vetäytyneen tekstin vasemman yläkulman.

Examples

Tämä esimerkki käyttää Graphics -luokkaa alkuperäisten muotojen luomiseen kuvan pinnalla.Toimintojen osoittamiseksi näytöllä luodaan uusi PNG-muotoinen kuva ja piirrät primitiiviset muodot Kuvan pinnan kautta grafiikan luokan esittämillä piirustusmenetelmillä.

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

Valitse määritellyn tekstiradan määritetyllä sijainnilla Aspose.Imaging.Brush- ja Wl17.Font-objektien kanssa käyttämällä määrittelemän __ WL16 _.StringFormatin muotoilun ominaisuuksia.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

x float

x-koordinaatti vasemman yläkulman piirretyn tekstin.

y float

Y-koordinaatti vasemman yläkulman piirretty teksti.

format StringFormat

Aspose.Imaging.StringFormat, joka määrittää muotoilun ominaisuuksia, kuten rivin tilavuus ja yhdenmukaistaminen, joita sovelletaan piirrettyyn tekstiin.

Exceptions

ArgumentNullException

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

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

Valitse määritellyn tekstiradan määritetyllä sijainnilla Aspose.Imaging.Brush- ja Wl17.Font-objektien kanssa käyttämällä määrittelemän __ WL16 _.StringFormatin muotoilun ominaisuuksia.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

point PointF

Aspose.Imaging.PointF-rakenne, joka määrittää vetäytyneen tekstin vasemman yläkulman.

format StringFormat

Aspose.Imaging.StringFormat, joka määrittää muotoilun ominaisuuksia, kuten rivin tilavuus ja yhdenmukaistaminen, joita sovelletaan piirrettyyn tekstiin.

Exceptions

ArgumentNullException

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

DrawString(Tyyny, Font, Brush, RectangleF)

Valitse määritellyn tekstin sarja määritetyllä oikea-osaan määrittelemällä Aspose.Imaging.Brush ja W L17.Font -objekti.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF rakenne, joka määrittää piirretyn tekstin sijainnin.

Exceptions

ArgumentNullException

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

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

Valitse määritellyn tekstin sarja määritetyllä oikea-osaan määrittelemällä Aspose.Imaging.Brush ja W L 17.Font -objekteja käyttämällä muotoilun ominaispiirteitä määritelmästä __ WL 17__ .StringFormat.

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

Parameters

s string

Kynttilät juontaa.

font Font

Aspose.Imaging.Fontti, joka määrittää sarjan tekstiformaatin.

brush Brush

Aspose.Imaging.Brush, joka määrittää värin ja tekstin.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF rakenne, joka määrittää piirretyn tekstin sijainnin.

format StringFormat

Aspose.Imaging.StringFormat, joka määrittää muotoilun ominaisuuksia, kuten rivin tilavuus ja yhdenmukaistaminen, joita sovelletaan piirrettyyn tekstiin.

Exceptions

ArgumentNullException

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

EndUpdate()

Lopetetaan graafisten toimintojen keräys, joka aloitettiin, kun BeginUpdate kutsuttiin. Edellinen graafinen toiminto sovelletaan heti tämän menetelmän soittamisen yhteydessä.

public void EndUpdate()

FillClosedCurve(Tyylikäs, PointF[])

Täytyy suljetun kardinaalin spline kurkun sisäpuolella, joka määritellään Aspose.Imaging.PointF-rakenteiden saralla.Tämä menetelmä käyttää oletusarvoisen jännitteen 0,5 ja W L17.FillMode.Alternate täyttää tilaa.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Tyylikäs, PointF[], ja FillMode)

Täytyy suljetun kardinaaliliitännän sisäpuolella, jonka määrittelee Aspose.Imaging.PointF-rakenteiden sarja käyttämällä määriteltyä täyttöä.Tämä menetelmä käyttää oletusarvoista jännitystä 0.5.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

fillMode FillMode

Jäsen Aspose.Imaging.FillMode luettelo, joka määrittää, miten kurkku täyttyy.

Exceptions

ArgumentNullException

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

FillClosedCurve(Tyylikäs, PointF[], FillMode ja Float)

Täytyy suljetun kardinaalisen virran sisäpuolella, jonka määrittelee Aspose.Imaging.PointF-rakenteiden sarja käyttämällä määriteltyä täyttömuotoa ja jännitystä.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points PointF []

Aspose.Imaging.PointF rakenteet, jotka määrittelevät spline.

fillmode FillMode

Jäsen Aspose.Imaging.FillMode luettelo, joka määrittää, miten kurkku täyttyy.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

FillClosedCurve(Painopiste, piste[])

Täytyy suljetun kardinaalin spline kurkun sisäpuolella, joka määritellään Aspose.Imaging.Point-rakenteiden saralla.Tämä menetelmä käyttää oletusarvoisen jännitteen 0,5 ja W L17.FillMode.Alternate -tila.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Painopiste, piste[], ja FillMode)

Täytyy suljetun kardinaaliliitännän sisäpuolella, joka määritellään Aspose.Imaging.Point-rakenteiden saralla käyttämällä ilmoitettua täyttöä.Tämä menetelmä käyttää oletusarvoista jännitystä 0.5.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

fillmode FillMode

Jäsen Aspose.Imaging.FillMode luettelo, joka määrittää, miten kurkku täyttyy.

Exceptions

ArgumentNullException

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

FillClosedCurve(Painopiste, piste[], FillMode ja Float)

Täytyy suljetun kardinaalisen virran sisäpuolella, joka määritellään Aspose.Imaging.Point-rakenteiden saralla käyttämällä ilmoitettua täyttömuotoa ja jännitystä.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points Point []

Aspose.Imaging.Pisteen rakenteet, jotka määrittelevät spline.

fillmode FillMode

Jäsen Aspose.Imaging.FillMode luettelo, joka määrittää, miten kurkku täyttyy.

tension float

Arvo, joka on suurempi tai yhtä suuri kuin 0,0F, joka määrittää kurkun jännityksen.

Exceptions

ArgumentNullException

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

FillEllipse(Rektangle ja Rectangle)

Täyttää ellipsin sisätilat, jotka on määritelty Aspose.Imaging.RectangleF -rakenteen mukaisella rajapinnalla.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka edustaa sidekohtaista rektangolia, jossa määritellään ellipsi.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Suihku, suihku, suihku, suihku)

Se täyttää ellipsin sisätilan, jonka määrittelee rintakehä, joka on määritelty pari koordinaattia, leveys ja korkeus.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x float

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

y float

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

width float

Syvyys rajanylitys, joka määrittää ellipsin.

height float

Korkeus rajattu reikiä, joka määrittelee ellipsi.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Kynttilät, Rectangle)

Täyttää ellipsin sisätilat, jotka on määritelty Aspose.Imaging.Rectangle rakenteen määrittelemällä rajapintaisella rektangulla.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect Rectangle

Aspose.Imaging.Rectangle rakenne, joka edustaa sidekohtaista rektangolia, jossa määritellään ellipsi.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Käärme, int, int, int, int)

Se täyttää ellipsin sisätilan, jonka määrittelee rintakehä, joka on määritelty pari koordinaattia, leveys ja korkeus.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x int

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

y int

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin.

width int

Syvyys rajanylitys, joka määrittää ellipsin.

height int

Korkeus rajattu reikiä, joka määrittelee ellipsi.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Käsikirjoitus, GraphicsPath)

Täyttää sisätilan Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

path GraphicsPath

Aspose.Imaging.GraphicsPath, joka edustaa polkua täyttämään.

Exceptions

ArgumentNullException

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

FillPie(Käärme, Rectangle, Float, Float)

Täytyy piirin sisätilo, joka määritellään Aspose.Imaging.RectangleF -rakenteella ja kahdella radiaalisella viivalla.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect Rectangle

Aspose.Imaging.Rectangle rakenne, joka edustaa sidekohtaista rektangeliä, jossa määritellään ellipsi, josta pie-osasto tulee.

startAngle float

Kynttilät astetta mitataan kellonaikaisesti x-aksin ensimmäiseltä puolelta pie-osasta.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ -parametrista pie-osaston toiselle puolelle.

Examples

Seuraava esimerkki näyttää, miten koostetaan animoitu GIF-kuva yksittäisistä Gif-blokeista.

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

Täytyy piirin sisätilo, joka määritellään Aspose.Imaging.RectangleF -rakenteella ja kahdella radiaalisella viivalla.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka edustaa sidekohtaista rektangolia, jossa määritellään ellipsi, josta pi-osasto tulee.

startAngle float

Kynttilät astetta mitataan kellonaikaisesti x-aksin ensimmäiseltä puolelta pie-osasta.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ -parametrista pie-osaston toiselle puolelle.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Laivasto, laivasto, laivasto, laivasto, laivasto)

Täyttää piirin sisätilojen määritelty ellipsi, joka on määritelty pari koordinaatteja, leveys, korkeus ja kaksi radiaalista linjaa.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x float

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piikkikohta tulee.

y float

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piikkikohta tulee.

width float

Syvyys rajanylitys, joka määrittelee ellipsin, josta jalkaosasto tulee.

height float

Korkeus rajanylitys, joka määrittelee ellipsin, josta jalkaosasto tulee.

startAngle float

Kynttilät astetta mitataan kellonaikaisesti x-aksin ensimmäiseltä puolelta pie-osasta.

sweepAngle float

Kynttilät asteissa mitataan kellotietä startAngle’ -parametrista pie-osaston toiselle puolelle.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Käärme, int, int, int, int, int)

Täyttää piirin sisätilojen määritelty ellipsi, joka on määritelty pari koordinaatteja, leveys, korkeus ja kaksi radiaalista linjaa.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x int

X-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piikkikohta tulee.

y int

Y-koordinaatti vasemman yläkulman sidekohta, joka määrittelee ellipsin, josta piikkikohta tulee.

width int

Syvyys rajanylitys, joka määrittelee ellipsin, josta jalkaosasto tulee.

height int

Korkeus rajanylitys, joka määrittelee ellipsin, josta jalkaosasto tulee.

startAngle int

Kynttilät astetta mitataan kellonaikaisesti x-aksin ensimmäiseltä puolelta pie-osasta.

sweepAngle int

Kynttilät asteissa mitataan kellotietä startAngle’ -parametrista pie-osaston toiselle puolelle.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Tyylikäs, PointF[])

Se täyttää polygonin sisätilan, jonka määrittelee Aspose.Imaging.PointF-rakenteiden ja Wl17.FillMode.Alternatin määrittämät pisteet.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points PointF []

Aspose.Imaging.PointF -rakenteiden sarja, jotka edustavat polygonin vertikaaleja täyttämään.

Exceptions

ArgumentNullException

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

FillPolygon(Tyylikäs, PointF[], ja FillMode)

Täyttää polygonin sisätilat, jotka määritellään Aspose.Imaging.PointF-rakenteiden määrittelemällä määritetyn täyttömuodon avulla.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points PointF []

Aspose.Imaging.PointF -rakenteiden sarja, jotka edustavat polygonin vertikaaleja täyttämään.

fillMode FillMode

Jäsen Aspose.Imaging.FillMode -luettelon, joka määrittää täyden tyylin.

Exceptions

ArgumentNullException

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

FillPolygon(Painopiste, piste[])

Se täyttää polygonin sisätilan, joka määritellään Aspose.Imaging.Point-rakenteiden ja Wl17.FillMode.Alternatin määrittelemällä pisteiden saralla.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points Point []

Valikoima Aspose.Imaging.Piste rakenteita, jotka edustavat vertikaalit polygonin täyttää.

Exceptions

ArgumentNullException

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

FillPolygon(Painopiste, piste[], ja FillMode)

Täyttää polygonin sisätilat, jotka määritellään Aspose.Imaging.Point-rakenteiden määrittelemällä määritetyn täyttymismenettelyn avulla.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

points Point []

Valikoima Aspose.Imaging.Piste rakenteita, jotka edustavat vertikaalit polygonin täyttää.

fillMode FillMode

Jäsen Aspose.Imaging.FillMode -luettelon, joka määrittää täyden tyylin.

Exceptions

ArgumentNullException

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

FillRectangle(Kynttilät, Rectangle)

Täyttää sisäpuolella reikiä, joka on määritetty Aspose.Imaging.Rectangle rakenne.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect Rectangle

Aspose.Imaging.Rectangle rakenne, joka edustaa rektangli täyttää.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Rektangle ja Rectangle)

Täyttää sisäpuolella reikiä, joka on määritetty Aspose.Imaging.RectangleF rakenne.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rect RectangleF

Aspose.Imaging.RectangleF rakenne, joka edustaa rektangli täyttää.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Suihku, suihku, suihku, suihku)

Täyttää sisäpuolella reikiä, joka on määritelty pari koordinaatteja, leveys ja korkeus.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x float

x-koordinaatti vasemman yläkulman reikiä täyttää.

y float

Y-koordinaatti vasemman yläkulman reikiä täyttää.

width float

Kynttilän leveys täyttää.

height float

Korkeus reikiä täyttää.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Käärme, int, int, int, int)

Täyttää sisäpuolella reikiä, joka on määritelty pari koordinaatteja, leveys ja korkeus.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

x int

x-koordinaatti vasemman yläkulman reikiä täyttää.

y int

Y-koordinaatti vasemman yläkulman reikiä täyttää.

width int

Kynttilän leveys täyttää.

height int

Korkeus reikiä täyttää.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Kynttilät, Rectangle[])

Täyttää sisätilojen sarjan reikiä, jotka on määritelty Aspose.Imaging.Rectangle rakenteita.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rects Rectangle []

Aspose.Imaging.Rectangle rakenteet, jotka edustavat rectangles täyttää.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Rektangle ja Rectangle[])

Täyttää sisätilojen sarjan reikiä, jotka on määritelty Aspose.Imaging.RectangleF rakenteita.

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

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

rects RectangleF []

Aspose.Imaging.Rectangle rakenteet, jotka edustavat rectangles täyttää.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, alue)

Se täyttää sisätilan Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush, joka määrittää täyden ominaisuudet.

region Region

Aspose.Imaging.Alue, joka edustaa aluetta täyttämään.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(String, Font, SizeF ja Strings)

Mittaa määritellyn tekstin sarjan määritetyillä parametreilla

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

Parameters

text string

tekstiä mitattavissa.

font Font

Määritettävissä oleva fontti.

layoutArea SizeF

ja layout alueen.

stringFormat StringFormat

Se on string formaatti.

Returns

SizeF

Pikselin koko mitattu tekstin sarja

MultiplyTransform(Matrix)

Se moninkertaistaa Aspose.Imaging.Matrixin, joka edustaa tämän W L 17.Grafiikan paikallista geometrista muutosta määritellyllä __ W L 18_ .Matriksillä, esittelemällä määritetyn _V L 19 _ Matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix jonka avulla moninkertaistaa geometrinen muutos.

MultiplyTransform(Matrix ja MatrixOrder)

Se moninkertaistaa Aspose.Imaging.Matrix, joka edustaa tämän Wl17.Grafiikan paikallista geometrista muuntamista määritellyllä __ WL16_ .Matriksilla määritetyssä järjestyksessä.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Aspose.Imaging.Matrix jonka avulla moninkertaistaa geometrinen muutos.

order MatrixOrder

Aspose.Imaging.MatrixOrder, joka määrittää, mihin tarkoitukseen kaksinkertaistaa matriisit.

ResetTransform()

Uudistaa Aspose.Imaging.Graphics.Transform omaisuus identiteettiin.

public void ResetTransform()

RotateTransform(Flottaa)

Kiertää paikallinen geometrinen muuntaminen määritellyn määrän mukaan.Tämä menetelmä sitoo muuntamisen muuntamiseen.

public void RotateTransform(float angle)

Parameters

angle float

Pyöreän kierroksen kulma.

RotateTransform(Lähde MatrixOrder)

Kääntyy paikallinen geometrinen muuntaminen määritellyn määrän mukaan määritellyssä järjestyksessä.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

Pyöreän kierroksen kulma.

order MatrixOrder

Aspose.Imaging.MatrixOrder, jossa määritetään, lisätäänkö tai prependataanko pyöritysmatriisi.

ScaleTransform(Laivasto, laivasto)

Laske paikallinen geometrinen muuntaminen määritettyjen määrien mukaan. Tämä menetelmä sitoo asteittaisen matriisin muuntamiseen.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

Määrä, jolla vaihdetaan muuntumista x-aksin suuntaan.

sy float

Määrä, jolla vaihdetaan muuntumista y-aksin suuntaan.

ScaleTransform(Matriisi, Matriisi ja Matriisi)

Laske paikallinen geometrinen muutos määritettyjen määrien mukaan määritellyssä järjestyksessä.

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

Parameters

sx float

Määrä, jolla vaihdetaan muuntumista x-aksin suuntaan.

sy float

Määrä, jolla vaihdetaan muuntumista y-aksin suuntaan.

order MatrixOrder

Aspose.Imaging.MatrixOrder, jossa määritetään, lisätäänkö matriisi vai etukäteen.

TranslateTransform(Laivasto, laivasto)

Siirtää paikallinen geometrinen muutos määritellyn ulottuvuuden mukaan.Tämä menetelmä sitoo käännöksen muutokseen.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Käännöksen arvo x.

dy float

Käännöksen arvo y.

TranslateTransform(Matriisi, Matriisi ja Matriisi)

Siirretään paikallinen geometrinen muutos määritettyjen ulottuvuuksien määritellyssä järjestyksessä.

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

Parameters

dx float

Käännöksen arvo x.

dy float

Käännöksen arvo y.

order MatrixOrder

Sääntö (prepend tai append) jossa käännöstä sovelletaan.

 Suomi