Class Graphics

Class Graphics

Nom dels espais: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.4.0)

Representa els gràfics d’acord amb el motor gráfic utilitzat en l’assemblació actual.

public sealed class Graphics

Inheritance

object Graphics

Membres heretats

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

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

Inicialitza una nova instància de la classe Aspose.Imaging.Gràfica.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

La imatge de la font.

Properties

Clip

Obté o col·loca la regió de clip.

public Region Clip { get; set; }

Valor de la propietat

Region

CompositingQuality

Obté o estableix la qualitat de la composició.

public CompositingQuality CompositingQuality { get; set; }

Valor de la propietat

CompositingQuality

Dpix

Obté la resolució horitzontal d’aquest Aspose.Imaging.Gràfics.

public float DpiX { get; }

Valor de la propietat

float

Dpi

Obté la resolució vertical d’aquest Aspose.Imaging.Gràfics.

public float DpiY { get; }

Valor de la propietat

float

Image

Obtenir la imatge.

public Image Image { get; }

Valor de la propietat

Image

InterpolationMode

Obté o estableix el mode d’interpolació.

public InterpolationMode InterpolationMode { get; set; }

Valor de la propietat

InterpolationMode

IsInBeginUpdateCall

Obté un valor que indica si els gràfics estan en l’estat de trucada de BeginUpdate.

public bool IsInBeginUpdateCall { get; }

Valor de la propietat

bool

PageScale

Obté o estableix l’escalació entre les unitats del món i les pàgines per a aquest Aspose.Imaging.Gràfics.

public float PageScale { get; set; }

Valor de la propietat

float

PageUnit

Obté o col·loca l’unitat de mesura utilitzada per a les coordenades de la pàgina en aquest Aspose.Imaging.Gràfics.

public GraphicsUnit PageUnit { get; set; }

Valor de la propietat

GraphicsUnit

PaintableImageOptions

Obté o s’estableix les opcions d’imatge, utilitzades per crear imatges de vacs pintables per dibuixar.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valor de la propietat

ImageOptionsBase

SmoothingMode

Obtenir o establir el mode de suavitat.

public SmoothingMode SmoothingMode { get; set; }

Valor de la propietat

SmoothingMode

TextRenderingHint

Obté o s’estableix l’indicador de rendiment del text.

public TextRenderingHint TextRenderingHint { get; set; }

Valor de la propietat

TextRenderingHint

Transform

Obté o col·loca una còpia de la transformació geomètrica del món per a aquest Aspose.Imaging.Gràfics.

public Matrix Transform { get; set; }

Valor de la propietat

Matrix

Methods

BeginUpdate()

Els efectes gràfics aplicats després no s’aplicaran immediatament en lloc de l’EndUpdate causarà la aplicació de tots els resultats alhora.

public void BeginUpdate()

Remarks

Noteu que els efectes després de l’anomenat BeginUpdate no s’aplicaran en el cas que EndUp Date no es crida.

Clear(Color)

Es neteja la superfície gràfica utilitzant el color especificat.

public void Clear(Color color)

Parameters

color Color

El color per netejar la superfície gràfica.

Examples

Aquests exemples fan ús de la classe GraphicsPath i Gràfics per crear i manipular Figures en una superfície d’imatge. Exemple crea una nova imatge (de tipus Tiff), neteja la superficial i treu els camins amb l’ajuda de Class Grapics.

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

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

//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(La flota, la float, el clavegueram, l’escorça)

Un arc representa una porció d’una el·lípsa especificada per un parell de coordenades, una amplada i una alçada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del arc.

x float

El x-coordinat de l’angle superior esquerre de la rectangla que defineix la el·lípsa.

y float

El coordenat y de l’angle superior esquerre de la rectangla que defineix la el·lípsa.

width float

L’amplada del rectangle que defineix l’el·lipsis.

height float

L’altura del rectangle que defineix l’el·lipsis.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al punt de partida del arc.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ per acabar el punt de l’arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, flotant, float)

Tracta un arc que representa una porció d’una el·lipsa especificada per una estructura Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del arc.

rect RectangleF

Aspose.Imaging.RectangleF estructura que defineix els límits de l’ellipsi.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al punt de partida del arc.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ per acabar el punt de l’arc.

Exceptions

ArgumentNullException

pen’ is null

DrawArc(Pen, Int, int, INT,int,Int i els altres)

Un arc representa una porció d’una el·lípsa especificada per un parell de coordenades, una amplada i una alçada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del arc.

x int

El x-coordinat de l’angle superior esquerre de la rectangla que defineix la el·lípsa.

y int

El coordenat y de l’angle superior esquerre de la rectangla que defineix la el·lípsa.

width int

L’amplada del rectangle que defineix l’el·lipsis.

height int

L’altura del rectangle que defineix l’el·lipsis.

startAngle int

Angle en graus mesurats de manera horitzontal des de l’eix x fins al punt de partida del arc.

sweepAngle int

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ per acabar el punt de l’arc.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, Rectangle, Float, float)

Tracta un arc que representa una porció d’una el·lípsa especificada per una estructura Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del arc.

rect Rectangle

Aspose.Imaging.RectangleF estructura que defineix els límits de l’ellipsi.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al punt de partida del arc.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ per acabar el punt de l’arc.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

//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(La flota, la float, el clavegueram, l’escorça, les flotes, els flots)

Es tracta d’una línia Bézier definida per quatre parells ordenats de coordenades que representen punts.

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 que determina el color, la amplada i l’estil de la curva.

x1 float

El x-coordinat del punt de partida de la curva.

y1 float

La coordenada y del punt de partida de la curva.

x2 float

El x-coordinat del primer punt de control de la curva.

y2 float

El coordenat y del primer punt de control de la curva.

x3 float

El x-coordinat del segon punt de control de la curva.

y3 float

La coordenada y del segon punt de control de la curva.

x4 float

La coordenada x del punt final de la curva.

y4 float

La coordenada y del punt final de la curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pen, PointF, PuntF i puntF)

Disposa d’una línia Bézier definida per quatre estructures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la curva.

pt1 PointF

Aspose.Imaging.PointF estructura que representa el punt de partida de la curva.

pt2 PointF

Aspose.Imaging.PointF estructura que representa el primer punt de control de la curva.

pt3 PointF

Aspose.Imaging.PointF estructura que representa el segon punt de control de la curva.

pt4 PointF

Aspose.Imaging.PointF estructura que representa el punt final de la curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Punts, punts, punt i punt)

Disposa d’una línia Bézier definida per quatre estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen estructura que determina el color, la amplada i l’estil de la curva.

pt1 Point

Aspose.Imaging.Estructura del punt que representa el punt de partida de la curva.

pt2 Point

Aspose.Imaging.Construcció de punts que representa el primer punt de control de la curva.

pt3 Point

Aspose.Imaging.Construcció de punts que representa el segon punt de control de la curva.

pt4 Point

Aspose.Imaging.Estructura del punt que representa el punt final de la curva.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

Tracta una sèrie de rellotges de Bézier a partir d’un seguit de estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la curva.

points Point []

Arreu de Aspose.Imaging.Estructures de punt que representen els punts que determinen la curva.

Exceptions

ArgumentNullException

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

DrawBeziers(El punt, el punt[])

Tracta una sèrie d’esplines de Bézier a partir de l’arxiu de estructures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen els punts que determinen la curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(El punt, el punt[])

Disposa d’una línia cardinal tancada definida per una sèrie de estructures Aspose.Imaging.PointF. Aquest mètode utilitza una tensió predeterminada de 0.5 i W L17.FillMode.Alternate mode de recull.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

Exceptions

ArgumentNullException

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

DrawClosedCurve(El punt, el punt[]La flota)

Tracta una línia cardinal tancada definida per una sèrie de estructures Aspose.Imaging.PointF utilitzant una tensió especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(El punt, el punt[])

Disposa d’una ronda cardinal tancada definida per una sèrie de estructures Aspose.Imaging.Point. Aquest mètode utilitza una tensió predeterminada de 0.5 i W L17.FillMode.Alternate mode de càrrega.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

Exceptions

ArgumentNullException

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

DrawClosedCurve(El punt, el punt[]La flota)

Tracta una ronda cardinal tancada definida per una sèrie de estructures Aspose.Imaging.Point utilitzant una tensió especificada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[])

Tracta una ronda cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.PointF. Aquest mètode utilitza una tensió estàndard de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[]La flota)

Tracta una línia cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.PointF utilitzant una tensió específica.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen els punts que defineixen la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[], i int, int)

Tracta una línia cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.PointF. El dibuix comença descomptat des del començament de l’arrel.Aquest mètode utilitza una tensió estàndard de 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

offset int

Descompte des del primer element en l’arrel de la punts’ paràmetre al punt de partida en la curva.

numberOfSegments int

Nombre de segments després del punt d’inici a incloure en la curva.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[], int, int i float)

Tracta una línia cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.PointF utilitzant una tensió específica.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

offset int

Descompte des del primer element en l’arrel de la punts’ paràmetre al punt de partida en la curva.

numberOfSegments int

Nombre de segments després del punt d’inici a incloure en la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[])

Tracta una ronda cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

//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(El punt, el punt[]La flota)

Tracta una línia cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.Point utilitzant una tensió específica.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawCurve(El punt, el punt[], int, int i float)

Tracta una línia cardinal a través d’una sèrie especificada de estructures Aspose.Imaging.Point utilitzant una tensió específica.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’altura de la curva.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

offset int

Descompte des del primer element en l’arrel de la punts’ paràmetre al punt de partida en la curva.

numberOfSegments int

Nombre de segments després del punt d’inici a incloure en la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

DrawEllipse(Pen, Rectangle)

Tracta una el·lipsa definida per un límit Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la el·lipsa.

rect RectangleF

Aspose.Imaging.RectangleF estructura que defineix els límits de l’ellipsi.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(La flota, el clavegueram, la float)

Disposa d’una el·lipsa definida per un rectangle limitant especificat per una parella de coordenades, una alçada i una amplada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la el·lipsa.

x float

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa.

y float

El y-coordinat de l’angle superior esquerre del recte que defineix la el·lípsa.

width float

L’amplada del rectangle que defineix l’el·lipsis.

height float

L’alçada del rectangle que defineix l’el·lipsis.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, rectangle)

Disposa d’una el·lípsa especificada per una estructura de lligam Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la el·lipsa.

rect Rectangle

Aspose.Imaging.Estructura rectangular que defineix els límits de l’ellipsi.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

Disposa d’una el·lipsa definida per un rectangle limitant especificat per una parella de coordenades, una alçada i una amplada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la el·lipsa.

x int

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa.

y int

El y-coordinat de l’angle superior esquerre del recte que defineix la el·lípsa.

width int

L’amplada del rectangle que defineix l’el·lipsis.

height int

L’alçada del rectangle que defineix l’el·lipsis.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Imatge de PointF)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image, utilitzant la seva mida física original, en l’emplaçament especificat.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

Imatge per dibuixar amb.

point PointF

Aspose.Imaging.PointF estructura que representa l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, float i flotant)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image, utilitzant la seva mida física original, en l’emplaçament especificat.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x float

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y float

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, RectangleF)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

Imatge per dibuixar amb.

rect RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicació i la mida de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, Rectangle, GraphicsUnit)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectDestination Rectangle

El destí rectangle.

graphicsUnit GraphicsUnit

Unitat de gràfics.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, RectangleF, GraphicsUnit)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectDestination RectangleF

El destí rectangle.

graphicsUnit GraphicsUnit

Unitat de gràfics.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, Rectangle, GraphicsUnit, ImageAttributes)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectDestination Rectangle

El destí rectangle.

graphicsUnit GraphicsUnit

Unitat de gràfics.

imageAttributes ImageAttributes

Els atributs de la imatge.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, RectangleF, GraphicsUnit, ImageAttributes)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectDestination RectangleF

El destí rectangle per treure.

graphicsUnit GraphicsUnit

Unitat de gràfics.

imageAttributes ImageAttributes

Els atributs de la imatge.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, Rectangle, GraphicsUnit)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectSource Rectangle

La font rectal.

rectDestination Rectangle

El destí de la direcció.

graphicsUnit GraphicsUnit

Unitat de gràfics.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, RectangleF, GraphicsUnit)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectSource RectangleF

La font rectal.

rectDestination RectangleF

El destí de la direcció.

graphicsUnit GraphicsUnit

Unitat de gràfics.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, Rectangle, GraphicsUnit, ImageAttributes)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectSource Rectangle

La font rectal.

rectDestination Rectangle

El destí de la direcció.

graphicsUnit GraphicsUnit

Unitat de gràfics.

imageAttributes ImageAttributes

Els atributs de la imatge.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, RectangleF, GraphicsUnit, ImageAttributes)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

rectSource RectangleF

La font rectangular.

rectDestination RectangleF

El destí rectangle.

graphicsUnit GraphicsUnit

Unitat de gràfics per utilitzar.

imageAttributes ImageAttributes

La imatge atribueix a utilitzar.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge i punt[])

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints Point []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

DrawImage(Imatge i punt[]El rectangle)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints Point []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect Rectangle

La font rectangular.

DrawImage(Imatge i punt[], Rectangle, gràficsUnit)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints Point []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect Rectangle

La font rectangular.

srcUnit GraphicsUnit

Les unitats de mesura.

DrawImage(Imatge i punt[], Rectangle, GraphicsUnit, ImageAttributes)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints Point []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect Rectangle

La font rectangular.

srcUnit GraphicsUnit

Les unitats de mesura.

imageAttributes ImageAttributes

Els atributs de la imatge.

DrawImage(Imatge de PointF[])

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints PointF []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

Exceptions

ArgumentNullException

Imatge

DrawImage(Imatge de PointF[]El rectangle)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints PointF []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect RectangleF

La font rectangular.

DrawImage(Imatge de PointF[], RectangleF, GraphicsUnit)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints PointF []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect RectangleF

La font rectangular.

srcUnit GraphicsUnit

Les unitats de mesura.

DrawImage(Imatge de PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Tracta la porció especificada de la imatge ’ a l’emplaçament especificat i amb la mida especifica.

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

Parameters

image Image

La imatge per dibuixar.

destPoints PointF []

Un conjunt de tres estructures PointF que defineixen un paral·lelogram.

srcRect RectangleF

La font rectangular.

srcUnit GraphicsUnit

Les unitats de mesura.

imageAttributes ImageAttributes

Els atributs de la imatge.

DrawImage(Imatge, flotada, float, flot)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x float

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y float

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

width float

Amplitud de la imatge dibuixada.

height float

Alçada de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge i punt)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image, utilitzant la seva mida física original, en l’emplaçament especificat.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

Imatge per dibuixar amb.

point Point

Aspose.Imaging.Estructura de punts que representa la ubicació de l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, int i int)

Tracta l’imatge especificada, utilitzant la seva mida física original, en el lloc especificat per un parell de coordenades.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x int

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y int

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge, Rectangle)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imatge per dibuixar amb.

rect Rectangle

Aspose.Imaging.Estructura rectangular que especifica la ubicació i la mida de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Imatge: int, int i int)

Tracta la imatge especificada Aspose.Imaging.Graphics.Image en l’emplaçament especificat i amb la mida especifica.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x int

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y int

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

width int

Amplitud de la imatge dibuixada.

height int

Alçada de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imatge i punt)

Tracta una imatge especificada utilitzant la seva mida física original en un lloc especificat.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

Imatge per dibuixar amb.

point Point

Aspose.Imaging.Construcció de punts que especifica l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imatge, int i int)

Tracta l’imatge especificada utilitzant la seva mida física original en el lloc especificat per un parell de coordenades.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x int

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y int

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imatge, Rectangle)

Tracta una imatge especificada utilitzant la seva mida física original en un lloc especificat.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imatge per dibuixar amb.

rect Rectangle

Aspose.Imaging.Rectangle que especifica la cantonada superior esquerra de l’imatge dibuixada.Les propietats X i Y de la rectangla especifiquen el cantonat superior dret.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Imatge: int, int i int)

Tracta una imatge especificada utilitzant la seva mida física original en un lloc especificat.

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

Parameters

sourceImage Image

Imatge per dibuixar amb.

x int

El coordenat x de l’angle superior esquerre de la imatge dibuixada.

y int

La coordenada y de l’angle superior esquerre de la imatge dibuixada.

width int

El paràmetre no s’utilitza.

height int

El paràmetre no s’utilitza.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Imatge, Rectangle)

Tracta la imatge especificada sense escalar i clipa-la, si és necessari, per encaixar-se en el rectangle especificat.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Imatge per dibuixar amb.

rect Rectangle

El Aspose.Imaging.Rectangle en el qual es pot dibuixar la imatge.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Pen, punt i punt)

Tracta una línia que connecta dues estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la línia.

point1 Point

Aspose.Imaging.Construcció de punts que representa el primer punt per connectar.

point2 Point

Aspose.Imaging.Construcció de punts que representa el segon punt per connectar.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, PointF i PuntF)

Tracta una línia que connecta dues estructures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la línia.

point1 PointF

Aspose.Imaging.PointF estructura que representa el primer punt per connectar.

point2 PointF

Aspose.Imaging.PointF estructura que representa el segon punt per connectar.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Imatge, int i int)

Entra una línia que connecta els dos punts especificats per les parelles de coordenades.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la línia.

x1 int

El x-coordinat del primer punt.

y1 int

El coordenat del primer punt.

x2 int

El x-coordinat del segon punt.

y2 int

El coordenat del segon punt.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(La flota, el clavegueram, la float)

Entra una línia que connecta els dos punts especificats per les parelles de coordenades.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la línia.

x1 float

El x-coordinat del primer punt.

y1 float

El coordenat del primer punt.

x2 float

El x-coordinat del segon punt.

y2 float

El coordenat del segon punt.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(El punt, el punt[])

Tracta una sèrie de segments de línia que connecten un seguit de estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil dels segments de la línia.

points Point []

Arxiu de estructures Aspose.Imaging.Point que representen els punts a connectar.

Exceptions

ArgumentNullException

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

ArgumentException

L’arreta de punts conté menys de 2 punts.

DrawLines(El punt, el punt[])

Tracta una sèrie de segments de línia que connecten un seguit de estructures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil dels segments de la línia.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen els punts a connectar.

Exceptions

ArgumentNullException

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

ArgumentException

L’arreta de punts conté menys de 2 punts.

DrawPath(Llistat, GraphicsPath)

Tracta un Aspose.Imaging.GraficsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del camí.

path GraphicsPath

Aspose.Imaging.GràficsPath per dibuixar.

Examples

Aquests exemples fan ús de la classe GraphicsPath i Gràfics per crear i manipular Figures en una superfície d’imatge. Exemple crea una nova imatge (de tipus Tiff), neteja la superficial i treu els camins amb l’ajuda de Class Grapics.

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

Disposa d’una forma de pie definida per un el·líps especificat per una estructura Aspose.Imaging.RectangleF i dues línies radials.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la forma del pie.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa la rectangla fronterera que defineix l’el·lípsis de la qual prové la forma del pie.

startAngle float

Angle mesurat en graus horitzontal des de l’eix x fins al primer costat de la forma de pie.

sweepAngle float

Angle mesurat en graus de manera horitzontal des del paràmetre startAngle’ al segon costat de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(La flota, la float, el clavegueram, l’escorça)

Disposa d’una forma de pie definida per una el·lípsa especificada per un parell de coordenades, una amplada, un alt, i dues línies radials.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la forma del pie.

x float

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la forma del pi.

y float

L’e-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la forma del pi.

width float

L’amplada del rectangle frontereri que defineix l’el·lipsis de la qual prové la forma del pie.

height float

L’alçada del rectangle frontereri que defineix l’el·lipsis des de la qual prové la forma del pie.

startAngle float

Angle mesurat en graus horitzontal des de l’eix x fins al primer costat de la forma de pie.

sweepAngle float

Angle mesurat en graus de manera horitzontal des del paràmetre startAngle’ al segon costat de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, Rectangle, Float, float)

Disposa d’una forma de pie definida per un el·líps especificat per una estructura Aspose.Imaging.Rectangle i dues línies radials.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la forma del pie.

rect Rectangle

Aspose.Imaging.Estructura rectangular que representa la recta frontera que defineix l’el·lípsis de la qual prové la forma de pie.

startAngle float

Angle mesurat en graus horitzontal des de l’eix x fins al primer costat de la forma de pie.

sweepAngle float

Angle mesurat en graus de manera horitzontal des del paràmetre startAngle’ al segon costat de la forma de pie.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, Int, int, INT,int,Int i els altres)

Disposa d’una forma de pie definida per una el·lípsa especificada per un parell de coordenades, una amplada, un alt, i dues línies radials.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de la forma del pie.

x int

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la forma del pi.

y int

L’e-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la forma del pi.

width int

L’amplada del rectangle frontereri que defineix l’el·lipsis de la qual prové la forma del pie.

height int

L’alçada del rectangle frontereri que defineix l’el·lipsis des de la qual prové la forma del pie.

startAngle int

Angle mesurat en graus horitzontal des de l’eix x fins al primer costat de la forma de pie.

sweepAngle int

Angle mesurat en graus de manera horitzontal des del paràmetre startAngle’ al segon costat de la forma de pie.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(El punt, el punt[])

Tracta un poligon definit per una sèrie de estructures Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del poligon.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen les vertices del poligon.

Exceptions

ArgumentNullException

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

DrawPolygon(El punt, el punt[])

Tracta un poligon definit per una sèrie de estructures Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del poligon.

points Point []

Arreu de Aspose.Imaging.Estructures de punt que representen les vertices del poligon.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, Rectangle)

Disposa d’un rectangle especificat per una estructura Aspose.Imaging.RectanglesF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen que determina el color, la amplada i l’estil del rectangle.

rect RectangleF

Es tracta d’una estructura Aspose.Imaging.RectangleF que representa la recta per dibuixar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, rectangle)

Disposa d’un rectangle especificat per una estructura Aspose.Imaging.Rectangles.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen que determina el color, la amplada i l’estil del rectangle.

rect Rectangle

Un Aspose.Imaging.Rectangle estructura que representa el rector per dibuixar.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

//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(La flota, el clavegueram, la float)

Disposa d’un rectangle especificat per un parell de coordenades, una amplada i una alçada.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen que determina el color, la amplada i l’estil del rectangle.

x float

El x-coordinat de l’angle superior esquerre de la rectangla per dibuixar.

y float

L’e-coordinat de l’angle superior esquerre de la recta per dibuixar.

width float

L’amplada del rectangle per dibuixar.

height float

L’alçada del rectangle per dibuixar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Imatge, int i int)

Disposa d’un rectangle especificat per un parell de coordenades, una amplada i una alçada.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil del rectangle.

x int

El x-coordinat de l’angle superior esquerre de la rectangla per dibuixar.

y int

L’e-coordinat de l’angle superior esquerre de la recta per dibuixar.

width int

Amplitud del rectangle per dibuixar.

height int

Alçada del rectangle per dibuixar.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pen, Rectangle[])

Tracta una sèrie de rectangles especificats per Aspose.Imaging.RectangleF estructures.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de les outlines dels rectangles.

rects RectangleF []

Arreu de Aspose.Imaging.RectangleF estructures que representen els rectangles per dibuixar.

Exceptions

ArgumentNullException

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

DrawRectangles(Pen, rectangle[])

Tracta una sèrie de rectangles especificats per Aspose.Imaging.Rectangle estructures.

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

Parameters

pen Pen

Aspose.Imaging.Pen que determina el color, la amplada i l’estil de les outlines dels rectangles.

rects Rectangle []

Arreu de Aspose.Imaging.Rectangle estructures que representen els rectangles per dibuixar.

Examples

Aquest exemple mostra la creació i l’ús d’objectes de pen. L’exemple crea una nova imatge i dibuixa rectangles a la superfície de la imatge.

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

Tracta la barra de text especificada en l’emplaçament especificat amb els objectes Aspose.Imaging.Brush i __ WL16_.Font específics.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

x float

El coordenat x de l’angle superior esquerre del text dibuixat.

y float

El coordenat y de l’angle superior esquerre del text dibuixat.

Exceptions

ArgumentNullException

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

DrawString(Llistat, Font, Brush i PointF)

Tracta la barra de text especificada en l’emplaçament especificat amb els objectes Aspose.Imaging.Brush i __ WL16_.Font específics.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

point PointF

Aspose.Imaging.PointF estructura que especifica l’angle superior esquerre del text dibuixat.

Examples

Aquest exemple utilitza la classe de gràfics per crear formes primitives a la superfície de la imatge.Per demostrar l’operació, l’exemple crea una nova imatge en format PNG i dibuixa formes primitives en la surface d’imatge utilitzant els mètodes de dibuix exposats per la categoria de graficis.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

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

DrawString(string, Font, Brush, flot, float, StringFormat)

Tracta la barra de text especificada en l’emplaçament especificat amb els objectes Aspose.Imaging.Brush i __ WL16_.Font específicament utilitzant els atributs de formatació de la especificació d’oficina.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

x float

El coordenat x de l’angle superior esquerre del text dibuixat.

y float

El coordenat y de l’angle superior esquerre del text dibuixat.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributs de formatació, com ara l’espai d’una línia i el alineament, que s’apliquen al text dibuixat.

Exceptions

ArgumentNullException

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

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

Tracta la barra de text especificada en l’emplaçament especificat amb els objectes Aspose.Imaging.Brush i __ WL16_.Font específicament utilitzant els atributs de formatació de la especificació d’oficina.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

point PointF

Aspose.Imaging.PointF estructura que especifica l’angle superior esquerre del text dibuixat.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributs de formatació, com ara l’espai d’una línia i el alineament, que s’apliquen al text dibuixat.

Exceptions

ArgumentNullException

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

DrawString(Llistat, Font, Brush, RectangleF)

Tracta la sèrie de text especificada en el rectangle especificat amb els objectes específics Aspose.Imaging.Brush i Wl17.Font.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicació del text dibuixat.

Exceptions

ArgumentNullException

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

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

Tracta la cadena de text especificada en el rectangle especificat amb l’objecte Aspose.Imaging.Brush i Wl17.Font específicament utilitzant els atributs de formatació de l’específic __ WL 17__ .StringFormat.

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

Parameters

s string

Tancats per dibuixar.

font Font

Aspose.Imaging.Font que defineix el format de text de la rama.

brush Brush

Aspose.Imaging.Brush que determina el color i la textura del text dibuixat.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF estructura que especifica la ubicació del text dibuixat.

format StringFormat

Aspose.Imaging.StringFormat que especifica atributs de formatació, com ara l’espai d’una línia i el alineament, que s’apliquen al text dibuixat.

Exceptions

ArgumentNullException

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

EndUpdate()

Finalitza el caching de les operacions gràfiques començades després que es cridés BeginUpdate.

public void EndUpdate()

FillClosedCurve(Brush i PointF[])

Omple l’interior d’una curva de fusta cardinal tancada definida per una sèrie de estructures Aspose.Imaging.PointF. Aquest mètode utilitza una tensió default de 0.5 i W L17.FillMode.Alternate mode de ompliment.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush i PointF[]El FillMode)

Omple l’interior d’una curva de rellotge cardinal tancada definida per una sèrie de estructures Aspose.Imaging.PointF utilitzant el mode de ompliment especificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

fillMode FillMode

Membre de l’enumeració Aspose.Imaging.FillMode que determina com s’omple la curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush i PointF[], FillMode, float)

Omple l’interior d’una curva de fusta cardinal tancada definida per una sèrie de estructures Aspose.Imaging.PointF utilitzant el mode de ompliment especificat i la tensió.

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

Parameters

brush Brush

Un WL17_.Brush que determina les característiques del full.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que defineixen l’espina.

fillmode FillMode

Membre de l’enumeració Aspose.Imaging.FillMode que determina com s’omple la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(El punt, el punt[])

Omple l’interior d’una curva de rellotge cardinal tancada definida per una sèrie de estructures Aspose.Imaging.Point. Aquest mètode utilitza una tensió predeterminada de 0.5 i W L17.FillMode.Alternate mode.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

Exceptions

ArgumentNullException

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

FillClosedCurve(El punt, el punt[]El FillMode)

Omple l’interior d’una curva de rellotge cardinal tancada definida per una sèrie de estructures Aspose.Imaging.Point utilitzant el mode de ompliment especificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

fillmode FillMode

Membre de l’enumeració Aspose.Imaging.FillMode que determina com s’omple la curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(El punt, el punt[], FillMode, float)

Omple l’interior d’una curva de fusta cardinal tancada definida per una sèrie de estructures Aspose.Imaging.Point utilitzant el mode de ompliment especificat i la tensió.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points Point []

Arreu de estructures Aspose.Imaging.Point que defineixen l’espina.

fillmode FillMode

Membre de l’enumeració Aspose.Imaging.FillMode que determina com s’omple la curva.

tension float

Valor superior o igual a 0.0F que especifica la tensió de la curva.

Exceptions

ArgumentNullException

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

FillEllipse(Brush i RectangleF)

Omple l’interior d’una el·lípsa definida per un rectangle de llarga distància especificat per una estructura Aspose.Imaging.RectanglesF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa la rectangla fronterera que defineix l’el·lipsis.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Fus, flot, float i flot)

Omple l’interior d’una el·lípsa definida per un rectangle limitant especificat per una parella de coordenades, una amplada i una alçada.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x float

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa.

y float

El y-coordinat de l’angle superior esquerre del recte que defineix la el·lípsa.

width float

L’amplada del rectangle que defineix l’el·lipsis.

height float

L’alçada del rectangle que defineix l’el·lipsis.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush i Rectangle)

Omple l’interior d’una el·lípsia definida per un rectangle de llarga distància especificat per una estructura Aspose.Imaging.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect Rectangle

Aspose.Imaging.Estructura rectangular que representa el rektangle frontereri que defineix l’ellipsi.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush, Int, int i int)

Omple l’interior d’una el·lípsa definida per un rectangle limitant especificat per una parella de coordenades, una amplada i una alçada.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x int

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa.

y int

El y-coordinat de l’angle superior esquerre del recte que defineix la el·lípsa.

width int

L’amplada del rectangle que defineix l’el·lipsis.

height int

L’alçada del rectangle que defineix l’el·lipsis.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Guió, GraphicsPath)

Omple l’interior d’un Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

path GraphicsPath

Aspose.Imaging.GraficsPath que representa el camí a omplir.

Exceptions

ArgumentNullException

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

FillPie(Brush, Rectangle, Float, float)

Omple l’interior d’una secció de pie definida per un el·líps especificat per una estructura Aspose.Imaging.RectangleF i dues línies radials.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect Rectangle

Aspose.Imaging.Estructura rectangular que representa la recta frontera que defineix l’el·lipsis des de la qual prové la secció pie.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al primer costat de la secció de pie.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ al segon costat de la secció pie.

Examples

L’exemple següent mostra com compondre una imatge de GIF animada des de blocs individuals.

string dir = "c:\\temp\\";

                                                                                                       // Create a GIF image 100 x 100 px.
                                                                                                       // The first block is fully black by default.
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                                       {
                                                                                                           // The first circle is red
                                                                                                           Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                           // The second circle is black
                                                                                                           Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                           // Gradually inscrease the angle of the red arc shape.
                                                                                                           for (int angle = 10; angle <= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                           for (int angle = 10; angle <= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush2, block.Bounds, 0, angle);
                                                                                                               gr.FillPie(brush1, block.Bounds, angle, 360 - angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           gifImage.Save(dir + "animated_radar.gif");
                                                                                                       }

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Brush, RectangleF, flotant, float)

Omple l’interior d’una secció de pie definida per un el·líps especificat per una estructura Aspose.Imaging.RectangleF i dues línies radials.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa la rectangla fronterera que defineix l’el·lípsis de la qual prové la secció pie.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al primer costat de la secció de pie.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ al segon costat de la secció pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(La flota, el brot, la float, els brots, les flotes)

Omple l’interior d’una secció de pie definida per una el·lípsa especificada per un parell de coordenades, una amplada, un alt i dues línies radials.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x float

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la secció pie.

y float

L’e-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la secció pie.

width float

L’amplada del rectangle frontereri que defineix l’el·lipsis de la qual prové la secció pie.

height float

L’alçada del rectangle frontereri que defineix l’el·lipsis des de la qual prové la secció pie.

startAngle float

Angle en graus mesurats de manera horitzontal des de l’eix x fins al primer costat de la secció de pie.

sweepAngle float

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ al segon costat de la secció pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Títol: Int, int i int)

Omple l’interior d’una secció de pie definida per una el·lípsa especificada per un parell de coordenades, una amplada, un alt i dues línies radials.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x int

El x-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la secció pie.

y int

L’e-coordinat de l’angle superior esquerre de la recta frontera que defineix la el·lípsa des d’on prové la secció pie.

width int

L’amplada del rectangle frontereri que defineix l’el·lipsis de la qual prové la secció pie.

height int

L’alçada del rectangle frontereri que defineix l’el·lipsis des de la qual prové la secció pie.

startAngle int

Angle en graus mesurats de manera horitzontal des de l’eix x fins al primer costat de la secció de pie.

sweepAngle int

Angle en graus mesurats de manera horitzontal des del paràmetre startAngle’ al segon costat de la secció pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush i PointF[])

Omple l’interior d’un poligon definit per una sèrie de punts especificats per les estructures Aspose.Imaging.PointF i W L17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen les vertices del poligon per omplir.

Exceptions

ArgumentNullException

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

FillPolygon(Brush i PointF[]El FillMode)

Omple l’interior d’un poligon definit per una sèrie de punts especificats per les estructures Aspose.Imaging.PointF utilitzant el mode de ompliment especificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points PointF []

Arreu de estructures Aspose.Imaging.PointF que representen les vertices del poligon per omplir.

fillMode FillMode

Membre de la Aspose.Imaging.FillMode enumeració que determina l’estil del ple.

Exceptions

ArgumentNullException

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

FillPolygon(El punt, el punt[])

Omple l’interior d’un poligon definit per una sèrie de punts especificats per Aspose.Imaging.Structures de punt i W L17.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points Point []

Arreu de Aspose.Imaging.Estructures de punt que representen les vertices del poligon per omplir.

Exceptions

ArgumentNullException

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

FillPolygon(El punt, el punt[]El FillMode)

Omple l’interior d’un poligon definit per una sèrie de punts especificats per Aspose.Imaging.Structures de punt utilitzant el mode de ompliment especificat.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

points Point []

Arreu de Aspose.Imaging.Estructures de punt que representen les vertices del poligon per omplir.

fillMode FillMode

Membre de la Aspose.Imaging.FillMode enumeració que determina l’estil del ple.

Exceptions

ArgumentNullException

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

FillRectangle(Brush i Rectangle)

Omple l’interior d’un rectangle especificat per una estructura Aspose.Imaging.Rectangles.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect Rectangle

Aspose.Imaging.Estructura rectangular que representa el rektangle a omplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush i RectangleF)

Omple l’interior d’un rectangle especificat per una estructura Aspose.Imaging.RectanglesF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rect RectangleF

Aspose.Imaging.RectangleF estructura que representa la rectangla a omplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Fus, flot, float i flot)

Omple l’interior d’un rectangle especificat per un parell de coordenades, una amplada i una alçada.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x float

El x-coordinat de l’angle superior esquerre de la rectangla per omplir.

y float

La coordenada y de l’angle superior esquerre de la rectangla per omplir.

width float

Amplitud del rectangle per omplir.

height float

Alçada del rectangle per omplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, Int, int i int)

Omple l’interior d’un rectangle especificat per un parell de coordenades, una amplada i una alçada.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

x int

El x-coordinat de l’angle superior esquerre de la rectangla per omplir.

y int

La coordenada y de l’angle superior esquerre de la rectangla per omplir.

width int

Amplitud del rectangle per omplir.

height int

Alçada del rectangle per omplir.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush i Rectangle[])

Omple els interiors d’una sèrie de rectangles especificats per Aspose.Imaging.Rectangle estructures.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rects Rectangle []

Arreu de Aspose.Imaging.Rectangle estructures que representen els rectangles a omplir.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Brush i RectangleF[])

Omple els interiors d’una sèrie de rectangles especificats per Aspose.Imaging.RectangleF estructures.

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

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

rects RectangleF []

Arreu de Aspose.Imaging.Rectangle estructures que representen els rectangles a omplir.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Regió)

Omple l’interior d’una Aspose.Imaging.Regió.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush que determina les característiques del full.

region Region

Aspose.Imaging.Regió que representa l’àrea a omplir.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(Llistat, font, SizeF, StringFormat)

Mesura la fila de text especificada amb paràmetres específics

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

Parameters

text string

El text per mesurar.

font Font

La font per mesurar.

layoutArea SizeF

L’àrea del layout.

stringFormat StringFormat

El format de string.

Returns

SizeF

Dimensió en píxels de string de text mesurat

MultiplyTransform(Matrix)

Es multiplica el Aspose.Imaging.Matrix que representa la transformació geomètrica local d’aquest Wl17.Gràfics per l’especificat _www.matrix, prependint el especificat _ww.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

La Aspose.Imaging.Matrix per la qual multiplicar la transformació geomètrica.

MultiplyTransform(Matriu i matriu)

Es multiplica el Aspose.Imaging.Matrix que representa la transformació geomètrica local d’aquest Wl17.Gràfics per l’especificat _www.matrix en el ordre especificat.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

La Aspose.Imaging.Matrix per la qual multiplicar la transformació geomètrica.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica en quin per multiplicar les dues matrius.

ResetTransform()

Reset la Aspose.Imaging.Graphics.Transforma la propietat en identitat.

public void ResetTransform()

RotateTransform(Float)

Rotarà la transformació geomètrica local per la quantitat especificada. aquest mètode prependrà la rotació al transformador.

public void RotateTransform(float angle)

Parameters

angle float

l’angle de la rotació.

RotateTransform(Lloc, MatrixOrder)

Rota la transformació geomètrica local per la quantitat especificada en l’ordre especificat.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

l’angle de la rotació.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica si afegir o prependre la matriu de rotació.

ScaleTransform(La flota, la flota)

Escalar la transformació geomètrica local per les quantitats especificades. Aquest mètode prepend la matriu d’escalada a la transformada.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

La quantitat per la qual escalar la transformació en la direcció x-axis.

sy float

La quantitat per la qual escalar la transformació en la direcció y-axis.

ScaleTransform(Float, float i matriu)

Escala la transformació geomètrica local per les quantitats especificades en l’ordre especificat.

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

Parameters

sx float

La quantitat per la qual escalar la transformació en la direcció x-axis.

sy float

La quantitat per la qual escalar la transformació en la direcció y-axis.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder que especifica si afegir o prependre la matriu d’escalació.

TranslateTransform(La flota, la flota)

Tradueix la transformació geomètrica local per les dimensions especificades.Aquest mètode prependrà la traducció al transformador.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

El valor de la traducció en x.

dy float

El valor de la traducció en i.

TranslateTransform(Float, float i matriu)

Tradueix la transformació geomètrica local per les dimensions especificades en l’ordre especificat.

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

Parameters

dx float

El valor de la traducció en x.

dy float

El valor de la traducció en i.

order MatrixOrder

L’ordre (prepend o append) en el qual aplicar la traducció.

 Català