Class Graphics

Class Graphics

Namn på plats: Aspose.Imaging Församling: Aspose.Imaging.dll (25.4.0)

Representerar grafik enligt den grafiska motorn som används i den aktuella uppsättningen.

public sealed class Graphics

Inheritance

object Graphics

Arvsmedlemmar

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

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Initialiserar en ny instans av Aspose.Imaging.Graphics klass.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

Källan för bilden.

Properties

Clip

Få eller ställa in klippregionen.

public Region Clip { get; set; }

Fastighetsvärde

Region

CompositingQuality

Få eller ställa in kompositionskvalitet.

public CompositingQuality CompositingQuality { get; set; }

Fastighetsvärde

CompositingQuality

Dpix

Få den horisontella upplösningen av denna Aspose.Imaging.Graphics.

public float DpiX { get; }

Fastighetsvärde

float

Dpiy

Få den vertikala upplösningen av denna Aspose.Imaging.Graphics.

public float DpiY { get; }

Fastighetsvärde

float

Image

får bilden.

public Image Image { get; }

Fastighetsvärde

Image

InterpolationMode

Få eller ställa in interpolationsläge.

public InterpolationMode InterpolationMode { get; set; }

Fastighetsvärde

InterpolationMode

IsInBeginUpdateCall

Få ett värde som indikerar om grafiken är i BeginUpdate call status.

public bool IsInBeginUpdateCall { get; }

Fastighetsvärde

bool

PageScale

Få eller ställa in skalan mellan världsenheter och sidsenheter för detta Aspose.Imaging.Graphics.

public float PageScale { get; set; }

Fastighetsvärde

float

PageUnit

Få eller ställa in enheten för mätning som används för sidkoordinater i denna Aspose.Imaging.Graphics.

public GraphicsUnit PageUnit { get; set; }

Fastighetsvärde

GraphicsUnit

PaintableImageOptions

Få eller ställa in bildalternativ, som används för att skapa målbara vactorbilder att dra.

public ImageOptionsBase PaintableImageOptions { get; set; }

Fastighetsvärde

ImageOptionsBase

SmoothingMode

Få eller ställa in smidigt läge.

public SmoothingMode SmoothingMode { get; set; }

Fastighetsvärde

SmoothingMode

TextRenderingHint

Få eller ställa in texten som ger en vägledning.

public TextRenderingHint TextRenderingHint { get; set; }

Fastighetsvärde

TextRenderingHint

Transform

Få eller ställa in en kopia av den geometriska världens transformation för denna Aspose.Imaging.Graphics.

public Matrix Transform { get; set; }

Fastighetsvärde

Matrix

Methods

BeginUpdate()

De grafiska effekter som tillämpas senare kommer inte att tillämpas omedelbart istället EndUpdate kommer att orsaka att alla effekter tillämpas samtidigt.

public void BeginUpdate()

Remarks

Observera att effekter efter BeginUpdate kallas inte kommer att tillämpas om EndUpdate inte kallas.

Clear(Color)

Rengör grafisk yta med den angivna färgen.

public void Clear(Color color)

Parameters

color Color

Färgen för att rensa grafikens yta.

Examples

Dessa exempel använder GraphicsPath och Graphics klass för att skapa och manipulera Figurer på en bild yta. Exempel skapar en ny bild (typ Tiff), rengör ytan och drar vägar med hjälp av GraphicsPath klass.

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

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en ark som representerar en del av en ellips som anges av ett par koordinater, en bredd och en höjd.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av arken.

x float

X-koordinaten i den övre vänstra hörnet av rektangeln som definierar ellipsen.

y float

Y-koordinaten i den övre vänstra hörnet av rektangeln som definierar ellipsen.

width float

bredden av rektangeln som definierar ellipsen.

height float

Höjd av rektangeln som definierar ellipsen.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till utgångspunkten för arken.

sweepAngle float

Vinkeln i grader mättes klockan från startAngle’ parameter till slutpunkten i arken.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, float, float)

Dra en ark som representerar en del av en ellips som anges av en Aspose.Imaging.RectangleF struktur.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av arken.

rect RectangleF

Aspose.Imaging.RectangleF struktur som definierar gränserna för ellipsen.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till utgångspunkten för arken.

sweepAngle float

Vinkeln i grader mättes klockan från startAngle’ parameter till slutpunkten i arken.

Exceptions

ArgumentNullException

pen’ is null

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

Dra en ark som representerar en del av en ellips som anges av ett par koordinater, en bredd och en höjd.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av arken.

x int

X-koordinaten i den övre vänstra hörnet av rektangeln som definierar ellipsen.

y int

Y-koordinaten i den övre vänstra hörnet av rektangeln som definierar ellipsen.

width int

bredden av rektangeln som definierar ellipsen.

height int

Höjd av rektangeln som definierar ellipsen.

startAngle int

Vinkeln i grader mätt klockan från x-axeln till utgångspunkten för arken.

sweepAngle int

Vinkeln i grader mättes klockan från startAngle’ parameter till slutpunkten i arken.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, Rectangle, Float, Float)

Dra en ark som representerar en del av en ellips som anges av en Aspose.Imaging.Rectangle struktur.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av arken.

rect Rectangle

Aspose.Imaging.RectangleF struktur som definierar gränserna för ellipsen.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till utgångspunkten för arken.

sweepAngle float

Vinkeln i grader mättes klockan från startAngle’ parameter till slutpunkten i arken.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en Bézier spline definierad av fyra beställda par koordinater som representerar punkter.

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 som bestämmer färg, bredd och stil av kurvan.

x1 float

x-koordinaten av startpunkten i kurvan.

y1 float

Y-koordinaten av startpunkten i kurvan.

x2 float

x-koordinaten av den första kontrollpunkten i kurvan.

y2 float

Y-koordinaten av den första kontrollpunkten i kurvan.

x3 float

x-koordinaten av den andra kontrollpunkten i kurvan.

y3 float

Y-koordinaten i den andra kontrollpunkten i kurvan.

x4 float

X-koordinaten av slutpunkten i kurvan.

y4 float

Y-koordinaten av slutpunkten i kurvan.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(PointF, PointF, PointF och PointF)

Dra en Bézier spline definierad av fyra Aspose.Imaging.PointF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av kurvan.

pt1 PointF

Aspose.Imaging.PointF struktur som representerar utgångspunkten för kurvan.

pt2 PointF

Aspose.Imaging.PointF struktur som representerar den första kontrollpunkten för kurvan.

pt3 PointF

Aspose.Imaging.PointF struktur som representerar den andra kontrollpunkten för kurvan.

pt4 PointF

Aspose.Imaging.PointF struktur som representerar slutpunkten i kurvan.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pen, Point, Point och Point)

Dra en Bézier spline definierad av fyra Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen struktur som bestämmer färg, bredd och stil av kurvan.

pt1 Point

Aspose.Imaging.Point struktur som representerar utgångspunkten för kurvan.

pt2 Point

Aspose.Imaging.Point struktur som representerar den första kontrollpunkten för kurvan.

pt3 Point

Aspose.Imaging.Point struktur som representerar den andra kontrollpunkten för kurvan.

pt4 Point

Aspose.Imaging.Point struktur som representerar slutpunkten i kurvan.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

//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(Pen, poäng[])

Dra en serie av Bézier splines från en rad Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som representerar de punkter som bestämmer kurvan.

Exceptions

ArgumentNullException

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

DrawBeziers(Pen och PointF[])

Dra en serie av Bézier splines från en rad Aspose.Imaging.PointF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar de punkter som bestämmer kurvan.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pen och PointF[])

Dra en stängd kardinal spline definierad av en rad av Aspose.Imaging.PointF strukturer. Denna metod använder en standardspänning på 0,5 och Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pen och PointF[ ], och flotta)

Dra en stängd kardinal spline definierad av en rad av Aspose.Imaging.PointF strukturer med en angiven spänning. Denna metod använder en standard Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pen, poäng[])

Dra en stängd kardinal spline definierad av en rad av Aspose.Imaging.Point strukturer. Denna metod använder en standardspänning på 0,5 och Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Pen, poäng[ ], och flotta)

Dra en stängd kardinal spline definierad av en rad av Aspose.Imaging.Point strukturer med en angiven spänning. Denna metod använder en standard Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawCurve(Pen och PointF[])

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.PointF strukturer. Denna metod använder en standardspänning på 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

Exceptions

ArgumentNullException

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

DrawCurve(Pen och PointF[ ], och flotta)

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.PointF strukturer med en angiven spänning.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar de punkter som definierar kurvan.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawCurve(Pen och PointF[ ], int , int)

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.PointF strukturer. ritningen börjar offset från början av raden.Denna metod använder en standardspänning på 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

offset int

Avsätt från det första elementet i raden points’ parameter till startpunkten i kurvan.

numberOfSegments int

Antal segment efter utgångspunkten att inkludera i kurvan.

Exceptions

ArgumentNullException

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

DrawCurve(Pen och PointF[ ], int , int , float)

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.PointF strukturer med en angiven spänning.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

offset int

Avsätt från det första elementet i raden points’ parameter till startpunkten i kurvan.

numberOfSegments int

Antal segment efter utgångspunkten att inkludera i kurvan.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawCurve(Pen, poäng[])

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

//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(Pen, poäng[ ], och flotta)

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.Point strukturer med en angiven spänning.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawCurve(Pen, poäng[ ], int , int , float)

Dra en kardinal spline genom en angiven rad av Aspose.Imaging.Point strukturer med en angiven spänning.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och höjd av kurvan.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

offset int

Avsätt från det första elementet i raden points’ parameter till startpunkten i kurvan.

numberOfSegments int

Antal segment efter utgångspunkten att inkludera i kurvan.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

DrawEllipse(Pen, RectangleF)

Dra en ellips definierad av en gräns Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av ellipsen.

rect RectangleF

Aspose.Imaging.RectangleF struktur som definierar gränserna för ellipsen.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, flotta, flotta, flotta, flotta)

Dra en ellips definierad av en gränssnittlig rektangel som anges av ett par koordinater, en höjd och en bredd.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av ellipsen.

x float

X-koordinaten i det övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

y float

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

width float

Gränssnittets bredd som definierar ellipsen.

height float

Höjden på den gränssnittliga rektangeln som definierar ellipsen.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, Rectangle)

Dra en ellips som anges av en gränssnitt Aspose.Imaging.Rectangle struktur.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av ellipsen.

rect Rectangle

Aspose.Imaging.Rectangle struktur som definierar gränserna för ellipsen.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en ellips definierad av en gränssnittlig rektangel som anges av ett par koordinater, en höjd och en bredd.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av ellipsen.

x int

X-koordinaten i det övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

y int

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

width int

Gränssnittets bredd som definierar ellipsen.

height int

Höjden på den gränssnittliga rektangeln som definierar ellipsen.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Bild från PointF)

Dra den angivna Aspose.Imaging.Graphics.Image, med hjälp av dess ursprungliga fysiska storlek, på den angivna platsen.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

Bilden att dra med.

point PointF

Aspose.Imaging.PointF struktur som representerar den övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Float, Float)

Dra den angivna Aspose.Imaging.Graphics.Image, med hjälp av dess ursprungliga fysiska storlek, på den angivna platsen.

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

Parameters

sourceImage Image

Bilden att dra med.

x float

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y float

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bilder från RectangleF)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

Bilden att dra med.

rect RectangleF

Aspose.Imaging.RectangleF struktur som anger platsen och storleken på den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Rectangle, GraphicsUnit)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectDestination Rectangle

Riktlinjen för destinationen.

graphicsUnit GraphicsUnit

Den grafiska enheten.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, RectangleF, GraphicsUnit)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectDestination RectangleF

Riktlinjen för destinationen.

graphicsUnit GraphicsUnit

Den grafiska enheten.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Rectangle, GraphicsUnit, ImageAttributer)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectDestination Rectangle

Riktlinjen för destinationen.

graphicsUnit GraphicsUnit

Den grafiska enheten.

imageAttributes ImageAttributes

Bilden har attribut.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, RectangleF, GraphicsUnit, ImageAttributer)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectDestination RectangleF

Destination rektangeln att dra in.

graphicsUnit GraphicsUnit

Den grafiska enheten.

imageAttributes ImageAttributes

Bilden har attribut.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Rectangle, Rectangle, Grafiken)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectSource Rectangle

Den rektala källan.

rectDestination Rectangle

Riktdestinationen är.

graphicsUnit GraphicsUnit

Den grafiska enheten.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, RectangleF, RectangleF, GrafikenUnit)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectSource RectangleF

Den rektala källan.

rectDestination RectangleF

Riktdestinationen är.

graphicsUnit GraphicsUnit

Den grafiska enheten.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Rectangle, Rectangle, GraphicsUnit, ImageAttributes)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectSource Rectangle

Den rektala källan.

rectDestination Rectangle

Riktdestinationen är.

graphicsUnit GraphicsUnit

Den grafiska enheten.

imageAttributes ImageAttributes

Bilden har attribut.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, RectangleF, RectangleF, GraphicsUnit, ImageAttributes)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

rectSource RectangleF

Källan är rektangeln.

rectDestination RectangleF

Riktlinjen för destinationen.

graphicsUnit GraphicsUnit

Den grafiska enheten att använda.

imageAttributes ImageAttributes

Bilden är attribut att använda.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(bild, punkt[])

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints Point [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

DrawImage(bild, punkt[ ], Om Rectangle)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints Point [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect Rectangle

Källan är rektangeln.

DrawImage(bild, punkt[ ], Rectangle, GraphicsUnit)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints Point [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect Rectangle

Källan är rektangeln.

srcUnit GraphicsUnit

och enheter av mätning.

DrawImage(bild, punkt[ ], Rectangle, GraphicsUnit, ImageAttributer)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints Point [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect Rectangle

Källan är rektangeln.

srcUnit GraphicsUnit

och enheter av mätning.

imageAttributes ImageAttributes

Bilden har attribut.

DrawImage(Bild från PointF[])

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints PointF [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

Exceptions

ArgumentNullException

Bilden

DrawImage(Bild från PointF[ ], RectangleF)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints PointF [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect RectangleF

Källan är rektangeln.

DrawImage(Bild från PointF[ ], RectangleF, GraphicsUnit)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints PointF [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect RectangleF

Källan är rektangeln.

srcUnit GraphicsUnit

och enheter av mätning.

DrawImage(Bild från PointF[ ], RectangleF, GraphicsUnit, ImageAttributer)

Dra den angivna delen av den angivna image’ på den angivna platsen och med den angivna storleken.

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

Parameters

image Image

Bilden att dra.

destPoints PointF [ ]

En uppsättning av tre PointF-strukturer som definierar ett parallelogram.

srcRect RectangleF

Källan är rektangeln.

srcUnit GraphicsUnit

och enheter av mätning.

imageAttributes ImageAttributes

Bilden har attribut.

DrawImage(Bild, flotta, flotta, flotta)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

x float

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y float

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

width float

bredden av den drabbade bilden.

height float

höjden på den drabbade bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(bild, punkt)

Dra den angivna Aspose.Imaging.Graphics.Image, med hjälp av dess ursprungliga fysiska storlek, på den angivna platsen.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

Bilden att dra med.

point Point

Aspose.Imaging.Point struktur som representerar platsen i övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, int, int)

Dra den angivna bilden, med hjälp av dess ursprungliga fysiska storlek, på den plats som anges av ett koordinatpar.

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

Parameters

sourceImage Image

Bilden att dra med.

x int

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y int

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, Rectangle)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Bilden att dra med.

rect Rectangle

Aspose.Imaging.Rectangle struktur som anger platsen och storleken på den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Bild, int, int, int, int)

Dra den angivna Aspose.Imaging.Graphics.Image på den angivna platsen och med den angivna storleken.

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

Parameters

sourceImage Image

Bilden att dra med.

x int

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y int

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

width int

bredden av den drabbade bilden.

height int

höjden på den drabbade bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(bild, punkt)

Dra en angiven bild med sin ursprungliga fysiska storlek på en angiven plats.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

Bilden att dra med.

point Point

Aspose.Imaging.Point struktur som anger den övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Bild, int, int)

Dra den angivna bilden med hjälp av dess ursprungliga fysiska storlek på den plats som anges av ett koordinatpar.

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

Parameters

sourceImage Image

Bilden att dra med.

x int

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y int

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Bild, Rectangle)

Dra en angiven bild med sin ursprungliga fysiska storlek på en angiven plats.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Bilden att dra med.

rect Rectangle

Aspose.Imaging.Rectangle som anger den övre vänstra hörnet av den dragna bilden. X och Y egenskaper av rektangeln anger den övre vänstra hörnet.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Bild, int, int, int, int)

Dra en angiven bild med sin ursprungliga fysiska storlek på en angiven plats.

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

Parameters

sourceImage Image

Bilden att dra med.

x int

X-koordinaten i den övre vänstra hörnet av den dragna bilden.

y int

Y-koordinaten i övre vänstra hörnet av den dragna bilden.

width int

Parametern används inte.

height int

Parametern används inte.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Bild, Rectangle)

Dra den angivna bilden utan att skala och klippa den, om nödvändigt, för att passa i den angivna rektangeln.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

Bilden att dra med.

rect Rectangle

Den Aspose.Imaging.Rectangle i vilken att dra bilden.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Pen, punkt och punkt)

Dra en linje som ansluter två Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen på linjen.

point1 Point

Aspose.Imaging.Point struktur som representerar den första punkten att ansluta.

point2 Point

Aspose.Imaging.Point struktur som representerar den andra punkten att ansluta.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en linje som ansluter två Aspose.Imaging.PointF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen på linjen.

point1 PointF

Aspose.Imaging.PointF struktur som representerar den första punkten att ansluta.

point2 PointF

Aspose.Imaging.PointF struktur som representerar den andra punkten att ansluta.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, int, int, int, int)

Dra en linje som ansluter de två punkterna som anges av koordinaterna.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen på linjen.

x1 int

Den x-koordinaten i första punkten.

y1 int

Den y-koordinaten i första punkten.

x2 int

X-koordinaten i den andra punkten.

y2 int

Y-koordinaten i den andra punkten.

Exceptions

ArgumentNullException

pen’ is null.

DrawLine(Pen, flotta, flotta, flotta, flotta)

Dra en linje som ansluter de två punkterna som anges av koordinaterna.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen på linjen.

x1 float

Den x-koordinaten i första punkten.

y1 float

Den y-koordinaten i första punkten.

x2 float

X-koordinaten i den andra punkten.

y2 float

Y-koordinaten i den andra punkten.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Pen, poäng[])

Dra en serie linje segment som ansluter en rad Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil i linje segment.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som representerar punkterna att ansluta.

Exceptions

ArgumentNullException

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

ArgumentException

Rutan points" innehåller mindre än 2 poäng.

DrawLines(Pen och PointF[])

Dra en serie linje segment som ansluter en rad Aspose.Imaging.PointF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil i linje segment.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar punkterna att ansluta.

Exceptions

ArgumentNullException

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

ArgumentException

Rutan points" innehåller mindre än 2 poäng.

DrawPath(Pen, GraphicsPath)

Skapa en Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen på vägen.

path GraphicsPath

Aspose.Imaging.GraphicsPath att rita.

Examples

Dessa exempel använder GraphicsPath och Graphics klass för att skapa och manipulera Figurer på en bild yta. Exempel skapar en ny bild (typ Tiff), rengör ytan och drar vägar med hjälp av GraphicsPath klass.

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

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

DrawPie(Pen, RectangleF, float, float)

Dra en pie form definierad av en ellips som anges av en Aspose.Imaging.RectangleF struktur och två radiala linjer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i pie form.

rect RectangleF

Aspose.Imaging.RectangleF struktur som representerar den gränssnittliga rektangeln som definierar ellipsen från vilken pie form kommer.

startAngle float

Vinkeln mäts i grader klockvis från x-axeln till den första sidan av pieformen.

sweepAngle float

Vinkel mätt i grader klockvis från startAngle’ parameter till den andra sidan av pie form.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, flotta, flotta, flotta, flotta, flotta)

Dra en pie form definierad av en ellips som anges av ett koordinatpar, en bredd, en höjd och två radiala linjer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i pie form.

x float

X-koordinaten av den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

y float

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

width float

bredden av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformet kommer.

height float

Höjden på den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

startAngle float

Vinkeln mäts i grader klockvis från x-axeln till den första sidan av pieformen.

sweepAngle float

Vinkel mätt i grader klockvis från startAngle’ parameter till den andra sidan av pie form.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, Rectangle, Float, Float)

Dra en pie form definierad av en ellips som anges av en Aspose.Imaging.Rectangle struktur och två radiala linjer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i pie form.

rect Rectangle

Aspose.Imaging.Rectangle struktur som representerar den gränssnitt rektangle som definierar ellipsen från vilken pie form kommer.

startAngle float

Vinkeln mäts i grader klockvis från x-axeln till den första sidan av pieformen.

sweepAngle float

Vinkel mätt i grader klockvis från startAngle’ parameter till den andra sidan av pie form.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, int, int, int, int, int, int)

Dra en pie form definierad av en ellips som anges av ett koordinatpar, en bredd, en höjd och två radiala linjer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i pie form.

x int

X-koordinaten av den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

y int

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

width int

bredden av den gränssnittliga rektangeln som definierar ellipsen från vilken pieformet kommer.

height int

Höjden på den gränssnittliga rektangeln som definierar ellipsen från vilken pieformen kommer.

startAngle int

Vinkeln mäts i grader klockvis från x-axeln till den första sidan av pieformen.

sweepAngle int

Vinkel mätt i grader klockvis från startAngle’ parameter till den andra sidan av pie form.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Pen och PointF[])

Dra en polygon definierad av en rad Aspose.Imaging.PointF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av polygonen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar vertikalerna i polygonen.

Exceptions

ArgumentNullException

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

DrawPolygon(Pen, poäng[])

Dra en polygon definierad av en rad Aspose.Imaging.Point strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil av polygonen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som representerar vertikalerna i polygonen.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en rektangel som anges av en Aspose.Imaging.RectangleF struktur.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

En Aspose.Imaging.Pen som bestämmer färg, bredd och stil i rektangeln.

rect RectangleF

En Aspose.Imaging.RectangleF struktur som representerar rektangeln att dra.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, Rectangle)

Dra en rektangle som anges av en Aspose.Imaging.Rectangle struktur.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

En Aspose.Imaging.Pen som bestämmer färg, bredd och stil i rektangeln.

rect Rectangle

En Aspose.Imaging.Rectangle struktur som representerar rektangeln att dra.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

Dra en rektangel som anges av ett koordinatpar, en bredd och en höjd.

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

Parameters

pen Pen

En Aspose.Imaging.Pen som bestämmer färg, bredd och stil i rektangeln.

x float

X-koordinaten av den övre vänstra hörnet av rektangeln att dra.

y float

Y-koordinaten av den övre vänstra hörnet av rektangeln att dra.

width float

bredden av rektangeln att dra.

height float

Höjden på rektangeln att dra.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, int, int, int, int)

Dra en rektangel som anges av ett koordinatpar, en bredd och en höjd.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färg, bredd och stil i rektangeln.

x int

X-koordinaten av den övre vänstra hörnet av rektangeln att dra.

y int

Y-koordinaten av den övre vänstra hörnet av rektangeln att dra.

width int

bredd av rektangeln att dra.

height int

Höjd av rektangeln att dra.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pen, RectangleF[])

Dra en serie rektanglar som anges av Aspose.Imaging.RectangleF strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i utskrifter av rektanglarna.

rects RectangleF [ ]

Array av Aspose.Imaging.RectangleF strukturer som representerar rektanglarna att dra.

Exceptions

ArgumentNullException

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

DrawRectangles(Pen, Rectangle[])

Dra en serie rektanglar som anges av Aspose.Imaging.Rectangle strukturer.

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

Parameters

pen Pen

Aspose.Imaging.Pen som bestämmer färgen, bredden och stilen i utskrifter av rektanglarna.

rects Rectangle [ ]

Array av Aspose.Imaging.Rectangle strukturer som representerar rektanglarna att dra.

Examples

Detta exempel visar skapandet och användningen av Pen objekt. exemplet skapar en ny bild och dra Rectangles på bildens yta.

//Create an instance of BmpOptions and set its various properties
                                                                                                                                       Aspose.Imaging.ImageOptions.BmpOptions bmpOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
                                                                                                                                       bmpOptions.BitsPerPixel = 24;

                                                                                                                                       //Create an instance of FileCreateSource and assign it as Source for the instance of BmpOptions
                                                                                                                                       //Second Boolean parameter determines if the file to be created IsTemporal or not
                                                                                                                                       bmpOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(@"C:\temp\sample.bmp", false);

                                                                                                                                       //Create an instance of Image at specified Path
                                                                                                                                       using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(bmpOptions, 500, 500))
                                                                                                                                       {
                                                                                                                                           //Create an instance of Graphics and initialize it with Image object
                                                                                                                                           Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                           //Clear the Graphics sutface with White Color
                                                                                                                                           graphics.Clear(Aspose.Imaging.Color.White);

                                                                                                                                           //Create an instance of Pen with color Red and width 5
                                                                                                                                           Aspose.Imaging.Pen pen = new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 5f);

                                                                                                                                           //Create an instance of HatchBrush and set its properties
                                                                                                                                           Aspose.Imaging.Brushes.HatchBrush brush = new Aspose.Imaging.Brushes.HatchBrush();
                                                                                                                                           brush.BackgroundColor = Aspose.Imaging.Color.Wheat;
                                                                                                                                           brush.ForegroundColor = Aspose.Imaging.Color.Red;

                                                                                                                                           //Create an instance of Pen
                                                                                                                                           //initialize it with HatchBrush object and width
                                                                                                                                           Aspose.Imaging.Pen brusedpen = new Pen(brush, 5);

                                                                                                                                           //Draw Rectangles by specifying Pen object
                                                                                                                                           graphics.DrawRectangles(pen, new[]
                                                                                                                                           {
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(210, 210), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(110, 110), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(310, 310), new Aspose.Imaging.Size(100, 100))
                                                                                                                                           });

                                                                                                                                           //Draw Rectangles by specifying Pen object
                                                                                                                                           graphics.DrawRectangles(brusedpen, new[]
                                                                                                                                           {
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(310, 110), new Aspose.Imaging.Size(100, 100)),
                                                                                                                                               new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(110, 310), new Aspose.Imaging.Size(100, 100))
                                                                                                                                           });

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

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, Float, Float)

Dra den angivna textrutan på den angivna platsen med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

x float

X-koordinaten i den övre vänstra hörnet av den dragen text.

y float

Y-koordinaten i den övre vänstra hörnet av den dragna texten.

Exceptions

ArgumentNullException

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

DrawString(Sträng, Font, Brush, PointF)

Dra den angivna textrutan på den angivna platsen med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

point PointF

Aspose.Imaging.PointF struktur som anger den övre vänstra hörnet av den dragna texten.

Examples

Detta exempel använder Graphics-klassen för att skapa primitiva former på bildytan. För att demonstrera operationen skapar exemplet en ny bild i PNG-format och dra primitiva former på bildytan med hjälp av ritningsmetoder som exponeras av Graphics-klassen.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exceptions

ArgumentNullException

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

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

Dra den angivna textrutan på den angivna platsen med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt med hjälp av formateringsattribut av angivna Aspose.Imaging.StringFormat.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

x float

X-koordinaten i den övre vänstra hörnet av den dragen text.

y float

Y-koordinaten i den övre vänstra hörnet av den dragna texten.

format StringFormat

Aspose.Imaging.StringFormat som anger formatering attribut, såsom linje spacing och anpassning, som tillämpas på den dragade texten.

Exceptions

ArgumentNullException

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

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

Dra den angivna textrutan på den angivna platsen med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt med hjälp av formateringsattribut av angivna Aspose.Imaging.StringFormat.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

point PointF

Aspose.Imaging.PointF struktur som anger den övre vänstra hörnet av den dragna texten.

format StringFormat

Aspose.Imaging.StringFormat som anger formatering attribut, såsom linje spacing och anpassning, som tillämpas på den dragade texten.

Exceptions

ArgumentNullException

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

DrawString(sträng, Font, Brush, RectangleF)

Dra den angivna textrutan i den angivna rektangeln med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struktur som anger platsen för dragen text.

Exceptions

ArgumentNullException

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

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

Dra den angivna textrutan i den angivna rektangeln med angivna Aspose.Imaging.Brush och Aspose.Imaging.Font objekt med hjälp av formateringsattribut av angivna Aspose.Imaging.StringFormat.

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

Parameters

s string

Sträng att dra.

font Font

Aspose.Imaging.Font som definierar textformatet i raden.

brush Brush

Aspose.Imaging.Brush som bestämmer färgen och texten i den dragna texten.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struktur som anger platsen för dragen text.

format StringFormat

Aspose.Imaging.StringFormat som anger formatering attribut, såsom linje spacing och anpassning, som tillämpas på den dragade texten.

Exceptions

ArgumentNullException

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

EndUpdate()

Avsluta caching av grafiska operationer startade efter BeginUpdate kallades. de föregående grafiska operationer kommer att tillämpas omedelbart när du ringer den här metoden.

public void EndUpdate()

FillClosedCurve(Brush och PointF[])

Fyller inredningen av en stängd kardinal spline curve definierad av en rad av Aspose.Imaging.PointF strukturer. Denna metod använder en standardspänning på 0,5 och Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush och PointF[ ], och FillMode)

Fyller inredningen av en stängd kardinal spline curve definierad av en rad Aspose.Imaging.PointF strukturer med det angivna fyllningsläget.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

fillMode FillMode

Medlem i Aspose.Imaging.FillMode-förteckningen som bestämmer hur kurvan fylls.

Exceptions

ArgumentNullException

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

FillClosedCurve(Brush och PointF[ ], FillMode, Float)

Fyller inredningen av en stängd kardinal spline curve definierad av en rad av Aspose.Imaging.PointF strukturer med hjälp av det angivna fyllningsläget och spänningen.

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

Parameters

brush Brush

En Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som definierar splinjen.

fillmode FillMode

Medlem i Aspose.Imaging.FillMode-förteckningen som bestämmer hur kurvan fylls.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bryssel, punkt[])

Fyller inredningen av en stängd kardinal spline curve definierad av en rad av Aspose.Imaging.Point strukturer. Denna metod använder en standardspänning på 0,5 och Aspose.Imaging.FillMode.Alternate fyllningsläge.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bryssel, punkt[ ], och FillMode)

Fyller inredningen av en stängd kardinal spline curve definierad av en uppsättning Aspose.Imaging.Point strukturer med det angivna fyllningsläget.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

fillmode FillMode

Medlem i Aspose.Imaging.FillMode-förteckningen som bestämmer hur kurvan fylls.

Exceptions

ArgumentNullException

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

FillClosedCurve(Bryssel, punkt[ ], FillMode, Float)

Fyller inredningen av en stängd kardinal spline curve definierad av en rad Aspose.Imaging.Point-strukturer med hjälp av det angivna fyllningsläget och spänningen.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som definierar splinjen.

fillmode FillMode

Medlem i Aspose.Imaging.FillMode-förteckningen som bestämmer hur kurvan fylls.

tension float

Värde större än eller lika med 0.0F som anger spänningen i kurvan.

Exceptions

ArgumentNullException

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

FillEllipse(Brush, RectangleF)

Fyller inredningen av en ellips definierad av en gränssnittlig rektangel som anges av en Aspose.Imaging.RectangleF struktur.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect RectangleF

Aspose.Imaging.RectangleF struktur som representerar den länk rektangeln som definierar ellipsen.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush, float, float, float, float)

Fyller inredningen av en ellips definierad av en gränssnittlig rektangel som anges av ett par koordinater, en bredd och en höjd.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x float

X-koordinaten i det övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

y float

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

width float

Gränssnittets bredd som definierar ellipsen.

height float

Höjden på den gränssnittliga rektangeln som definierar ellipsen.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Brush och rektangle)

Fyller inredningen av en ellips definierad av en gränssnittlig rektangle som anges av en Aspose.Imaging.Rectangle struktur.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect Rectangle

Aspose.Imaging.Rectangle struktur som representerar gränssnitt rektangle som definierar ellipsen.

Exceptions

ArgumentNullException

brush’ is null.

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

Fyller inredningen av en ellips definierad av en gränssnittlig rektangel som anges av ett par koordinater, en bredd och en höjd.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x int

X-koordinaten i det övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

y int

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar ellipsen.

width int

Gränssnittets bredd som definierar ellipsen.

height int

Höjden på den gränssnittliga rektangeln som definierar ellipsen.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Brush och GraphicsPath)

Fyller inuti en Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

path GraphicsPath

Aspose.Imaging.GraphicsPath som representerar vägen att fylla.

Exceptions

ArgumentNullException

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

FillPie(Brush, Rectangle, Float, Float)

Fyller inredningen av en pie sektion definierad av en ellips som anges av en Aspose.Imaging.RectangleF struktur och två radiala linjer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect Rectangle

Aspose.Imaging.Rectangle struktur som representerar den gränssnitt rektangle som definierar ellipsen från vilken pie sektionen kommer.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till den första sidan av pie sektionen.

sweepAngle float

Vinklar i grader mätt klockan från startAngle’ parameter till den andra sidan av pie sektionen.

Examples

Följande exempel visar hur man komponerar en animerad GIF-bild från enskilda GIF-block.

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

Fyller inredningen av en pie sektion definierad av en ellips som anges av en Aspose.Imaging.RectangleF struktur och två radiala linjer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect RectangleF

Aspose.Imaging.RectangleF struktur som representerar den gränssnittliga rektangeln som definierar ellipsen från vilken pie sektionen kommer.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till den första sidan av pie sektionen.

sweepAngle float

Vinklar i grader mätt klockan från startAngle’ parameter till den andra sidan av pie sektionen.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Brush, flotta, flotta, flotta, flotta, flotta, flotta)

Fyller inredningen av en pie sektion definierad av en ellips som anges av ett par koordinater, en bredd, en höjd och två radiala linjer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x float

X-koordinaten av den övre vänstra hörnet av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

y float

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

width float

bredden av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

height float

Höjden på den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

startAngle float

Vinkeln i grader mätt klockan från x-axeln till den första sidan av pie sektionen.

sweepAngle float

Vinklar i grader mätt klockan från startAngle’ parameter till den andra sidan av pie sektionen.

Exceptions

ArgumentNullException

brush’ is null.

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

Fyller inredningen av en pie sektion definierad av en ellips som anges av ett par koordinater, en bredd, en höjd och två radiala linjer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x int

X-koordinaten av den övre vänstra hörnet av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

y int

Y-koordinaten i den övre vänstra hörnet av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

width int

bredden av den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

height int

Höjden på den gränssnittliga rektangeln som definierar den ellips från vilken pie sektionen kommer.

startAngle int

Vinkeln i grader mätt klockan från x-axeln till den första sidan av pie sektionen.

sweepAngle int

Vinklar i grader mätt klockan från startAngle’ parameter till den andra sidan av pie sektionen.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Brush och PointF[])

Fyller inredningen av en polygon definierad av en rad punkter som anges av Aspose.Imaging.PointF strukturer och Aspose.Imaging.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar vertikalerna i polygonen att fylla.

Exceptions

ArgumentNullException

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

FillPolygon(Brush och PointF[ ], och FillMode)

Fyller inredningen av en polygon definierad av ett antal punkter som anges av Aspose.Imaging.PointF strukturer med det angivna fyllningsläget.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points PointF [ ]

Array av Aspose.Imaging.PointF strukturer som representerar vertikalerna i polygonen att fylla.

fillMode FillMode

Medlem i Aspose.Imaging.FillMode förteckning som bestämmer stil av fyllningen.

Exceptions

ArgumentNullException

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

FillPolygon(Bryssel, punkt[])

Fyller inredningen av en polygon definierad av en rad punkter som anges av Aspose.Imaging.Point strukturer och Aspose.Imaging.FillMode.Alternate.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som representerar vertikalerna i polygonen att fylla.

Exceptions

ArgumentNullException

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

FillPolygon(Bryssel, punkt[ ], och FillMode)

Fyller inredningen av en polygon definierad av ett antal punkter som anges av Aspose.Imaging.Point-strukturer med hjälp av det angivna fyllningsläget.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

points Point [ ]

Array av Aspose.Imaging.Point strukturer som representerar vertikalerna i polygonen att fylla.

fillMode FillMode

Medlem i Aspose.Imaging.FillMode förteckning som bestämmer stil av fyllningen.

Exceptions

ArgumentNullException

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

FillRectangle(Brush och rektangle)

Fyller inredningen av en rektangle som anges av en Aspose.Imaging.Rectangle struktur.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect Rectangle

Aspose.Imaging.Rectangle struktur som representerar rektangeln att fylla.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, RectangleF)

Fyller inredningen av en rektangel som anges av en Aspose.Imaging.RectangleF struktur.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rect RectangleF

Aspose.Imaging.RectangleF struktur som representerar rektangeln att fylla.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Brush, float, float, float, float)

Fyller inredningen av en rektangel som anges av ett par koordinater, bredd och höjd.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x float

X-koordinaten av den övre vänstra hörnet av rektangeln att fylla.

y float

Y-koordinaten av den övre vänstra hörnet av rektangeln att fylla.

width float

bredd av rektangeln att fylla.

height float

Höjd av rektangeln att fylla.

Exceptions

ArgumentNullException

brush’ is null.

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

Fyller inredningen av en rektangel som anges av ett par koordinater, bredd och höjd.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

x int

X-koordinaten av den övre vänstra hörnet av rektangeln att fylla.

y int

Y-koordinaten av den övre vänstra hörnet av rektangeln att fylla.

width int

bredd av rektangeln att fylla.

height int

Höjd av rektangeln att fylla.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Brush och rektangle[])

Fyller inredningen av en serie rektanglar som anges av Aspose.Imaging.Rectangle strukturer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rects Rectangle [ ]

Array av Aspose.Imaging.Rectangle strukturer som representerar rektanglarna att fylla.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Brush, RectangleF[])

Fyller inredningen av en serie rektanglar som anges av Aspose.Imaging.RectangleF strukturer.

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

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

rects RectangleF [ ]

Array av Aspose.Imaging.Rectangle strukturer som representerar rektanglarna att fylla.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Region)

Fyller inuti en Aspose.Imaging.Region.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

Aspose.Imaging.Brush som bestämmer egenskaperna hos fyllningen.

region Region

Aspose.Imaging.Region som representerar området att fylla.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(String, Font, SizeF, StringFormat)

Mät den angivna textrutan med angivna parametrar

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

Parameters

text string

Texten att mäta.

font Font

Bokstäver för att mäta.

layoutArea SizeF

och layoutområdet.

stringFormat StringFormat

Det är strängformat.

Returns

SizeF

Storlek i pixlar av mätt textsträng

MultiplyTransform(Matrix)

Det multiplicerar Aspose.Imaging.Matrix som representerar den lokala geometriska omvandlingen av denna Aspose.Imaging.Grafiken av den angivna Aspose.Imaging.Matrix genom att prependera den angivna Aspose.Imaging.Matrix.

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix genom vilken för att multiplicera den geometriska transformationen.

MultiplyTransform(Matrix och MatrixOrder)

Multiplicerar Aspose.Imaging.Matrix som representerar den lokala geometriska omvandlingen av denna Aspose.Imaging.Grafik av den angivna Aspose.Imaging.Matrix i den angivna ordningen.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Aspose.Imaging.Matrix genom vilken för att multiplicera den geometriska transformationen.

order MatrixOrder

En Aspose.Imaging.MatrixOrder som anger i vilken syfte att multiplicera de två matriserna.

ResetTransform()

Återställer Aspose.Imaging.Graphics.Transformerar egendom till identitet.

public void ResetTransform()

RotateTransform(Flotta)

Roterar den lokala geometriska omvandlingen med det angivna beloppet. Denna metod förknippar omvandlingen till omvandlingen.

public void RotateTransform(float angle)

Parameters

angle float

Vinkel av rotation.

RotateTransform(Föregående MatrixOrder)

Roterar den lokala geometriska omvandlingen med det angivna beloppet i den angivna ordningen.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

Vinkel av rotation.

order MatrixOrder

En Aspose.Imaging.MatrixOrder som anger om du ska bifoga eller bifoga rotationsmatrisen.

ScaleTransform(Flotta och flotta)

Skala den lokala geometriska transformationen med de angivna mängderna.Denna metod förknippar skalningsmatrisen med transformationen.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

Den mängd som ska skala transformationen i x-axis riktning.

sy float

Den mängd som ska skala transformationen i y-axis riktning.

ScaleTransform(Float, Float och MatrixOrder)

Skala den lokala geometriska omvandlingen med de angivna mängderna i den angivna ordningen.

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

Parameters

sx float

Den mängd som ska skala transformationen i x-axis riktning.

sy float

Den mängd som ska skala transformationen i y-axis riktning.

order MatrixOrder

En Aspose.Imaging.MatrixOrder som anger om du ska förlänga eller prepend skala matrisen.

TranslateTransform(Flotta och flotta)

Översätter den lokala geometriska transformationen genom de angivna dimensionerna.Denna metod förknippar översättningen med transformationen.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Värdet av översättningen i x.

dy float

Värdet av översättningen i y.

TranslateTransform(Float, Float och MatrixOrder)

Översätter den lokala geometriska transformationen av de angivna dimensionerna i den angivna ordningen.

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

Parameters

dx float

Värdet av översättningen i x.

dy float

Värdet av översättningen i y.

order MatrixOrder

Beställningen (prepend eller append) i vilken översättningen ska tillämpas.

 Svenska