Class Graphics

Class Graphics

Il nome: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.4.0)

Esso rappresenta la grafica in base al motore grafico utilizzato nell’attuale assemblaggio.

public sealed class Graphics

Inheritance

object Graphics

I membri ereditari

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

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Inizia una nuova instanza della classe Aspose.Imaging.Grafica.

public Graphics(Image sourceImage)

Parameters

sourceImage Image

L’immagine della fonte.

Properties

Clip

Ottieni o impostare la regione clip.

public Region Clip { get; set; }

Valore di proprietà

Region

CompositingQuality

Riceve o stabilisce la qualità compositiva.

public CompositingQuality CompositingQuality { get; set; }

Valore di proprietà

CompositingQuality

Il Dpix

Ottieni la risoluzione orizzontale di questo Aspose.Imaging.Grafica.

public float DpiX { get; }

Valore di proprietà

float

Il Dpi

Riceve la risoluzione verticale di questo Aspose.Imaging.Grafica.

public float DpiY { get; }

Valore di proprietà

float

Image

Riceve l’immagine

public Image Image { get; }

Valore di proprietà

Image

InterpolationMode

Riceve o impone il modo di interpolazione.

public InterpolationMode InterpolationMode { get; set; }

Valore di proprietà

InterpolationMode

IsInBeginUpdateCall

Riceve un valore che indica se il grafico è in stato di chiamata BeginUpdate.

public bool IsInBeginUpdateCall { get; }

Valore di proprietà

bool

PageScale

Ottieni o impostate la scala tra le unità mondiali e le unaità di pagina per questo Aspose.Imaging.Grafica.

public float PageScale { get; set; }

Valore di proprietà

float

PageUnit

Riceve o impone l’unità di misura utilizzata per le coordinate della pagina in questo Aspose.Imaging.Grafica.

public GraphicsUnit PageUnit { get; set; }

Valore di proprietà

GraphicsUnit

PaintableImageOptions

Riceve o impone le opzioni di immagine, utilizzate per creare immagini di vaccino colorabili da disegnare.

public ImageOptionsBase PaintableImageOptions { get; set; }

Valore di proprietà

ImageOptionsBase

SmoothingMode

Ottenere o impostare il modo di scivolare.

public SmoothingMode SmoothingMode { get; set; }

Valore di proprietà

SmoothingMode

TextRenderingHint

Riceve o mette il testo rendering indice.

public TextRenderingHint TextRenderingHint { get; set; }

Valore di proprietà

TextRenderingHint

Transform

Riceve o mette una copia della trasformazione del mondo geometrico per questo Aspose.Imaging.Grafica.

public Matrix Transform { get; set; }

Valore di proprietà

Matrix

Methods

BeginUpdate()

Gli effetti grafici applicati successivamente non saranno applicati immediatamente invece l’EndUpdate causerà l’applicazione di tutti gli effetti contemporaneamente.

public void BeginUpdate()

Remarks

Nota gli effetti dopo l’appello di StartUpdate non verrà applicato se EndUpdate non viene chiamato.

Clear(Color)

Pulisce la superficie grafica utilizzando il colore specificato.

public void Clear(Color color)

Parameters

color Color

Il colore per pulire la superficie della grafica.

Examples

Questi esempi utilizzano la classe GraphicsPath e la grafica per creare e manipolare le figure su una superficie dell’immagine. Esempio crea una nuova Immagine (di tipo Tiff), pulisce la superficie e traccia i percorsi con l’aiuto della classe Grafica.

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

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Disegna un arco che rappresenta una porzione di un ellipso specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’arca.

x float

Il coordinato x dell’angolo superiore a sinistra del rectangolo che definisce l’ellipso.

y float

Il coordinato y dell’angolo superiore sinistro del rectangolo che definisce l’ellipso.

width float

L’ampiezza del rettangolo che definisce l’ellipso.

height float

L’altezza del rectangolo che definisce l’ellipso.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al punto di partenza dell’arca.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ per finire il punto dell’arco.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, RectangleF, flotta, flotta)

Disegna un arco che rappresenta una porzione di un ellipso specificato da una struttura Aspose.Imaging.RectangleF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’arca.

rect RectangleF

Aspose.Imaging.RectangleF struttura che definisce i confini dell’ellipso.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al punto di partenza dell’arca.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ per finire il punto dell’arco.

Exceptions

ArgumentNullException

pen’ is null

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

Disegna un arco che rappresenta una porzione di un ellipso specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’arca.

x int

Il coordinato x dell’angolo superiore a sinistra del rectangolo che definisce l’ellipso.

y int

Il coordinato y dell’angolo superiore sinistro del rectangolo che definisce l’ellipso.

width int

L’ampiezza del rettangolo che definisce l’ellipso.

height int

L’altezza del rectangolo che definisce l’ellipso.

startAngle int

L’angolo in gradi misurato in modo orario dall’asse x al punto di partenza dell’arca.

sweepAngle int

L’angolo in gradi misurato in modo orario dal parametro startAngle’ per finire il punto dell’arco.

Exceptions

ArgumentNullException

pen’ is null.

DrawArc(Pen, rettangolo, float, float)

Disegna un arco che rappresenta una porzione di un ellipo specificato da una struttura Aspose.Imaging.Rectangle.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’arca.

rect Rectangle

Aspose.Imaging.RectangleF struttura che definisce i confini dell’ellipso.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al punto di partenza dell’arca.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ per finire il punto dell’arco.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Disegna una linea Bézier definita da quattro coppie ordinate di coordinate che rappresentano punti.

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 che determina il colore, la larghezza e lo stile della curva.

x1 float

Il coordinato x del punto di partenza della curva.

y1 float

Il coordinato y del punto di partenza della curva.

x2 float

Il coordinato x del primo punto di controllo della curva.

y2 float

Il coordinato y del primo punto di controllo della curva.

x3 float

Il coordinato x del secondo punto di controllo della curva.

y3 float

Il coordinato y del secondo punto di controllo della curva.

x4 float

Il coordinato x del punto di fine della curva.

y4 float

L’e-coordinato del punto di fine della curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Pen, PointF, PointF e PointF)

Traccia una linea Bézier definita da quattro strutture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della curva.

pt1 PointF

Aspose.Imaging.Struttura PointF che rappresenta il punto di partenza della curva.

pt2 PointF

Aspose.Imaging.PointF struttura che rappresenta il primo punto di controllo per la curva.

pt3 PointF

Aspose.Imaging.PointF struttura che rappresenta il secondo punto di controllo per la curva.

pt4 PointF

Aspose.Imaging.PointF struttura che rappresenta il punto di fine della curva.

Exceptions

ArgumentNullException

pen’ is null.

DrawBezier(Il punto, il punto, il punto)

Traccia una linea Bézier definita da quattro strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen struttura che determina il colore, la larghezza e lo stile della curva.

pt1 Point

Aspose.Imaging.Struttura del punto che rappresenta il punto di partenza della curva.

pt2 Point

Aspose.Imaging.Struttura del punto che rappresenta il primo punto di controllo della curva.

pt3 Point

Aspose.Imaging.Struttura del punto che rappresenta il secondo punto di controllo della curva.

pt4 Point

Aspose.Imaging.Struttura del punto che rappresenta il punto di fine della curva.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

//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(Il punto, punto[])

Ritratta una serie di spline di Bézier da un certo numero di strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punti che rappresentano i punti per determinare la curva.

Exceptions

ArgumentNullException

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

DrawBeziers(Il punto, il punto[])

Ritratta una serie di spline di Bézier da un certo numero di strutture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della curva.

points PointF [ ]

La serie di strutture Aspose.Imaging.PointF che rappresentano i punti che determinano la curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Il punto, il punto[])

Scopri una spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.PointF. Questo metodo utilizza una tensione predefinita di 0.5 e W L17.FillMode.Alternate modalità di riempimento.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Il punto, il punto[ ], La flotta)

Traccia una spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.PointF utilizzando una tensione specifica.Questo metodo utilizza il modulo di riempimento predefinito W L17.FillMode.Alterna.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Il punto, punto[])

Esegue una spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.Point.Questo metodo utilizza una tensione predefinita di 0.5 e W L17.FillMode.Alternate modalità riempimento.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

Exceptions

ArgumentNullException

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

DrawClosedCurve(Il punto, punto[ ], La flotta)

Traccia una spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.Point utilizzando una tensione specifica.Questo metodo utilizza il modulo di riempimento predefinito Wl17.FillMode.Alterna.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, il punto[])

Traccia una spline cardinale attraverso una serie specifica di strutture Aspose.Imaging.PointF. Questo metodo utilizza una tensione predefinita di 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, il punto[ ], La flotta)

Traccia una spline cardinale attraverso un ordine specifico di strutture Aspose.Imaging.PointF utilizzando una tensione specifica.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

La serie di strutture Aspose.Imaging.PointF che rappresentano i punti che definiscono la curva.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, il punto[ ], di int, int)

Ritratta una spline cardinale attraverso una serie specifica di strutture Aspose.Imaging.PointF. Il ritratto inizia a riprendere dall’inizio della serie.Questo metodo utilizza una tensione standard di 0.5.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

offset int

Disattivare dal primo elemento nella sequenza dei parametri points’ al punto di partenza nella curva.

numberOfSegments int

Numero di segmenti dopo il punto di partenza da includere nella curva.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, il punto[ ], int , int , float)

Ritratta una spline cardinale attraverso un ordine specifico di strutture Aspose.Imaging.PointF utilizzando una tensione specifica.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

offset int

Disattivare dal primo elemento nella sequenza dei parametri points’ al punto di partenza nella curva.

numberOfSegments int

Numero di segmenti dopo il punto di partenza da includere nella curva.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, punto[])

Traccia una spline cardinale attraverso una serie specifica di strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

//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(Il punto, punto[ ], La flotta)

Traccia una spline cardinale attraverso un ordine specifico di strutture Aspose.Imaging.Point utilizzando una tensione specifica.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawCurve(Il punto, punto[ ], int , int , float)

Traccia una spline cardinale attraverso un ordine specifico di strutture Aspose.Imaging.Point utilizzando una tensione specifica.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e l’altezza della curva.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

offset int

Disattivare dal primo elemento nella sequenza dei parametri points’ al punto di partenza nella curva.

numberOfSegments int

Numero di segmenti dopo il punto di partenza da includere nella curva.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

DrawEllipse(Pen, RectangleF)

Esegue un ellipso definito da un confine Aspose.Imaging.RectangleF.

public void DrawEllipse(Pen pen, RectangleF rect)

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’ellipso.

rect RectangleF

Aspose.Imaging.RectangleF struttura che definisce i confini dell’ellipso.

Exceptions

ArgumentNullException

pen’ is null.

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

Un ellipso definito da un rettangolo di confine specificato da un paio di coordinate, un’altezza e una larghezza.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’ellipso.

x float

Il coordinato x dell’angolo superiore a sinistra del rectangolo di confine che definisce l’ellipso.

y float

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso.

width float

La larghezza del rettangolo di confine che definisce l’ellipso.

height float

L’altezza del rectangolo di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

pen’ is null.

DrawEllipse(Pen, Rettangolo)

Disegna un ellipso specificato da una struttura di confine Aspose.Imaging.Rectangle.

public void DrawEllipse(Pen pen, Rectangle rect)

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’ellipso.

rect Rectangle

Aspose.Imaging.Struttura retangolare che definisce i confini dell’ellipso.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Un ellipso definito da un rettangolo di confine specificato da un paio di coordinate, un’altezza e una larghezza.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dell’ellipso.

x int

Il coordinato x dell’angolo superiore a sinistra del rectangolo di confine che definisce l’ellipso.

y int

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso.

width int

La larghezza del rettangolo di confine che definisce l’ellipso.

height int

L’altezza del rectangolo di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

pen’ is null.

DrawImage(Immagini di PointF)

Ritratta il Aspose.Imaging.Graphics.Image specificato, utilizzando la sua dimensione fisica originale, nella posizione specificata.

public void DrawImage(Image sourceImage, PointF point)

Parameters

sourceImage Image

L’immagine da disegnare.

point PointF

Aspose.Imaging.PointF struttura che rappresenta l’angolo superiore a sinistra dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, flotta, flotta)

Ritratta il Aspose.Imaging.Graphics.Image specificato, utilizzando la sua dimensione fisica originale, nella posizione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x float

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y float

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagini di RectangleF)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

public void DrawImage(Image sourceImage, RectangleF rect)

Parameters

sourceImage Image

L’immagine da disegnare.

rect RectangleF

Aspose.Imaging.RectangleF struttura che specifica la posizione e la dimensione dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagini, Rectangle, GraphicsUnit)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectDestination Rectangle

Il destino rettangolo.

graphicsUnit GraphicsUnit

Unità di grafica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, RectangleF, GraphicsUnit)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectDestination RectangleF

Il destino rettangolo.

graphicsUnit GraphicsUnit

Unità di grafica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, Rectangle, GraphicsUnit, Attributi di immagine)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectDestination Rectangle

Il destino rettangolo.

graphicsUnit GraphicsUnit

Unità di grafica.

imageAttributes ImageAttributes

Le immagini attribuiscono.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, RectangleF, GraphicsUnit, Attributi di immagine)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectDestination RectangleF

Il destino rettangolo da tirare in.

graphicsUnit GraphicsUnit

Unità di grafica.

imageAttributes ImageAttributes

Le immagini attribuiscono.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, Rectangle, Rectangle, GraficaUnit)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectSource Rectangle

La fonte della retta.

rectDestination Rectangle

La destinazione retta.

graphicsUnit GraphicsUnit

Unità di grafica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, RectangleF, RectangleF, GraphicsUnit)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectSource RectangleF

La fonte della retta.

rectDestination RectangleF

La destinazione retta.

graphicsUnit GraphicsUnit

Unità di grafica.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, Rectangle, Rectangle, GraphicsUnit, Attributi di immagine)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectSource Rectangle

La fonte della retta.

rectDestination Rectangle

La destinazione retta.

graphicsUnit GraphicsUnit

Unità di grafica.

imageAttributes ImageAttributes

Le immagini attribuiscono.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, RectangleF, RectangleF, GraphicsUnit, Attributi di immagine)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

rectSource RectangleF

Il rectangolo della fonte.

rectDestination RectangleF

Il destino rettangolo.

graphicsUnit GraphicsUnit

L’unità grafica da utilizzare.

imageAttributes ImageAttributes

L’immagine è attribuita all’uso.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Il punto, il punto[])

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

DrawImage(Il punto, il punto[ ], di Rectangle)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect Rectangle

Il rectangolo della fonte.

DrawImage(Il punto, il punto[ ], Rectangle, GraphicsUnit)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect Rectangle

Il rectangolo della fonte.

srcUnit GraphicsUnit

Unità di misura.

DrawImage(Il punto, il punto[ ], Rectangle, GraphicsUnit, Attributi di immagine)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints Point [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect Rectangle

Il rectangolo della fonte.

srcUnit GraphicsUnit

Unità di misura.

imageAttributes ImageAttributes

Le immagini attribuiscono.

DrawImage(Immagini di PointF[])

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

Exceptions

ArgumentNullException

Immagine

DrawImage(Immagini di PointF[ ], di RectangleF)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect RectangleF

Il rectangolo della fonte.

DrawImage(Immagini di PointF[ ], RectangleF, GraphicsUnit)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect RectangleF

Il rectangolo della fonte.

srcUnit GraphicsUnit

Unità di misura.

DrawImage(Immagini di PointF[ ], RectangleF, GraphicsUnit, Attributi di immagini)

Ritratta la porzione specifica dell’immagine ’ nella posizione specifica e con la dimensione specifica.

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

Parameters

image Image

L’immagine da disegnare.

destPoints PointF [ ]

Si tratta di una serie di tre strutture PointF che definiscono un parallelogramma.

srcRect RectangleF

Il rectangolo della fonte.

srcUnit GraphicsUnit

Unità di misura.

imageAttributes ImageAttributes

Le immagini attribuiscono.

DrawImage(Immagine, flotta, flotta, flotta, flotta)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x float

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y float

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

width float

L’ampiezza dell’immagine ritratta.

height float

L’altezza dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Il punto, il punto)

Ritratta il Aspose.Imaging.Graphics.Image specificato, utilizzando la sua dimensione fisica originale, nella posizione specificata.

public void DrawImage(Image sourceImage, Point point)

Parameters

sourceImage Image

L’immagine da disegnare.

point Point

Aspose.Imaging.Struttura di punto che rappresenta la posizione dell’angolo superiore a sinistra della immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, int, int)

Ritratta l’immagine specificata, utilizzando la sua dimensione fisica originale, nella posizione specificata da una coppia di coordinate.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x int

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y int

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagini di Rectangle)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

public void DrawImage(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’immagine da disegnare.

rect Rectangle

Aspose.Imaging.Struttura retangolare che specifica la posizione e la dimensione dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImage(Immagine, int, int, int, int)

Ritratta il Aspose.Imaging.Graphics.Immagine specificato nella posizione specifica e con la dimensione specificata.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x int

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y int

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

width int

L’ampiezza dell’immagine ritratta.

height int

L’altezza dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Il punto, il punto)

Ritratta un’immagine specifica utilizzando la sua dimensione fisica originale in una posizione specifica.

public void DrawImageUnscaled(Image sourceImage, Point point)

Parameters

sourceImage Image

L’immagine da disegnare.

point Point

Aspose.Imaging.Struttura di punto che specifica l’angolo superiore a sinistra dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Immagine, int, int)

Ritratta l’immagine specificata utilizzando la sua dimensione fisica originale nella posizione specificata da una coppia di coordinate.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x int

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y int

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Immagini di Rectangle)

Ritratta un’immagine specifica utilizzando la sua dimensione fisica originale in una posizione specifica.

public void DrawImageUnscaled(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’immagine da disegnare.

rect Rectangle

Aspose.Imaging.Rectangle che specifica l’angolo superiore a sinistra dell’immagine ritratta.Le proprietà X e Y del rectanglio specificano il angolo inferiore di sinistro.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaled(Immagine, int, int, int, int)

Ritratta un’immagine specifica utilizzando la sua dimensione fisica originale in una posizione specifica.

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

Parameters

sourceImage Image

L’immagine da disegnare.

x int

Il coordinato x dell’angolo superiore a sinistra dell’immagine ritratta.

y int

Il coordinato y dell’angolo superiore a sinistra dell’immagine ritratta.

width int

Il parametro non viene utilizzato.

height int

Il parametro non viene utilizzato.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawImageUnscaledAndClipped(Immagini di Rectangle)

Traccia l’immagine specificata senza scalare e la copre, se necessario, per adattarsi alla rettangola specificata.

public void DrawImageUnscaledAndClipped(Image sourceImage, Rectangle rect)

Parameters

sourceImage Image

L’immagine da disegnare.

rect Rectangle

Il Aspose.Imaging.Rectangolo in cui disegnare l’immagine.

Exceptions

ArgumentNullException

sourceImage’ is null.

DrawLine(Il punto, il punto)

Traccia una linea che collega due strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della linea.

point1 Point

Aspose.Imaging.Struttura del punto che rappresenta il primo punto da collegare.

point2 Point

Aspose.Imaging.Struttura del punto che rappresenta il secondo punto da collegare.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Traccia una linea che collega due strutture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della linea.

point1 PointF

Aspose.Imaging.PointF struttura che rappresenta il primo punto da collegare.

point2 PointF

Aspose.Imaging.PointF struttura che rappresenta il secondo punto da collegare.

Exceptions

ArgumentNullException

pen’ is null.

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

Esegue una linea che collega i due punti specificati dalle coppie di coordinate.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della linea.

x1 int

Il coordinato x del primo punto.

y1 int

Il coordinato del primo punto.

x2 int

Il coordinato x del secondo punto.

y2 int

Il coordinato del secondo punto.

Exceptions

ArgumentNullException

pen’ is null.

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

Esegue una linea che collega i due punti specificati dalle coppie di coordinate.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della linea.

x1 float

Il coordinato x del primo punto.

y1 float

Il coordinato del primo punto.

x2 float

Il coordinato x del secondo punto.

y2 float

Il coordinato del secondo punto.

Exceptions

ArgumentNullException

pen’ is null.

DrawLines(Il punto, punto[])

Ritratta una serie di segmenti di linea che collegano una gamma di strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dei segmenti della linea.

points Point [ ]

Una serie di strutture Aspose.Imaging.Point che rappresentano i punti da collegare.

Exceptions

ArgumentNullException

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

ArgumentException

La gamma di punti contiene meno di 2 punti.

DrawLines(Il punto, il punto[])

Ritratta una serie di segmenti di linea che collegano una gamma di strutture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile dei segmenti della linea.

points PointF [ ]

Una serie di strutture Aspose.Imaging.PointF che rappresentano i punti da collegare.

Exceptions

ArgumentNullException

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

ArgumentException

La gamma di punti contiene meno di 2 punti.

DrawPath(Giochi, GraphicsPath)

Scrivere un Aspose.Imaging.GraphicsPath.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del percorso.

path GraphicsPath

Aspose.Imaging.GraficaPath per disegnare.

Examples

Questi esempi utilizzano la classe GraphicsPath e la grafica per creare e manipolare le figure su una superficie dell’immagine. Esempio crea una nuova Immagine (di tipo Tiff), pulisce la superficie e traccia i percorsi con l’aiuto della classe Grafica.

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

Disegna una forma di pie definita da un ellipso specificato da una struttura Aspose.Imaging.RectangleF e due linee radiali.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della forma del piede.

rect RectangleF

Aspose.Imaging.RectangleF struttura che rappresenta il rettangolo di confine che definisce l’ellipso da cui viene la forma del piede.

startAngle float

L’angolo misurato in gradi orario dall’asse x al primo lato della forma del piede.

sweepAngle float

L’angolo misurato in gradi in modo orario dalla startParametro dell’angolo al secondo lato della forma del piede.

Exceptions

ArgumentNullException

pen’ is null.

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

Disegna una forma di piede definita da un ellipso specificato da una coppia di coordinate, una larghezza, una altezza e due linee radiali.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della forma del piede.

x float

Il coordinato x dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

y float

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

width float

La larghezza del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

height float

L’altezza del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

startAngle float

L’angolo misurato in gradi orario dall’asse x al primo lato della forma del piede.

sweepAngle float

L’angolo misurato in gradi in modo orario dalla startParametro dell’angolo al secondo lato della forma del piede.

Exceptions

ArgumentNullException

pen’ is null.

DrawPie(Pen, rettangolo, float, float)

Disegna una forma di pie definita da un ellipso specificato da una struttura Aspose.Imaging.Rectangle e due linee radiali.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della forma del piede.

rect Rectangle

Aspose.Imaging.Struttura rettangolare che rappresenta la retangola di confine che definisce l’ellipso da cui proviene la forma del piede.

startAngle float

L’angolo misurato in gradi orario dall’asse x al primo lato della forma del piede.

sweepAngle float

L’angolo misurato in gradi in modo orario dalla startParametro dell’angolo al secondo lato della forma del piede.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Disegna una forma di piede definita da un ellipso specificato da una coppia di coordinate, una larghezza, una altezza e due linee radiali.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile della forma del piede.

x int

Il coordinato x dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

y int

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

width int

La larghezza del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

height int

L’altezza del rettangolo di confine che definisce l’ellipso da cui proviene la forma del piede.

startAngle int

L’angolo misurato in gradi orario dall’asse x al primo lato della forma del piede.

sweepAngle int

L’angolo misurato in gradi in modo orario dalla startParametro dell’angolo al secondo lato della forma del piede.

Exceptions

ArgumentNullException

pen’ is null.

DrawPolygon(Il punto, il punto[])

Disegna un poligono definito da una serie di strutture Aspose.Imaging.PointF.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del poligono.

points PointF [ ]

Aria di Aspose.Imaging.PointF strutture che rappresentano le verticali del poligono.

Exceptions

ArgumentNullException

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

DrawPolygon(Il punto, punto[])

Traccia un poligono definito da una serie di strutture Aspose.Imaging.Point.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del poligono.

points Point [ ]

Aria di Aspose.Imaging.Strutture di punto che rappresentano le verticali del poligono.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Disegna un rettangolo specificato da una struttura Aspose.Imaging.RectangleF.

public void DrawRectangle(Pen pen, RectangleF rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del rettangolo.

rect RectangleF

Una struttura Aspose.Imaging.RectangleF che rappresenta il rettangolo da disegnare.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangle(Pen, Rettangolo)

Disegna un rettangolo specificato da una struttura Aspose.Imaging.Rectangle.

public void DrawRectangle(Pen pen, Rectangle rect)

Parameters

pen Pen

Un Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del rettangolo.

rect Rectangle

Una struttura Aspose.Imaging.Rectangle che rappresenta il rettangolo da disegnare.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Traccia un rettangolo specificato da una coppia di coordinate, una larghezza e una altezza.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del rettangolo.

x float

Il coordinato x dell’angolo superiore a sinistra del rectangolo da disegnare.

y float

Il coordinato y dell’angolo superiore a sinistra del rectangolo per tirare.

width float

La larghezza del rectangolo da disegnare.

height float

L’altezza del rectangolo da disegnare.

Exceptions

ArgumentNullException

pen’ is null.

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

Traccia un rettangolo specificato da una coppia di coordinate, una larghezza e una altezza.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile del rettangolo.

x int

Il coordinato x dell’angolo superiore a sinistra del rectangolo da disegnare.

y int

Il coordinato y dell’angolo superiore a sinistra del rectangolo per tirare.

width int

L’ampiezza del rectangolo da disegnare.

height int

L’altezza del rectangolo da disegnare.

Exceptions

ArgumentNullException

pen’ is null.

DrawRectangles(Pen, RectangleF[])

Disegna una serie di rettangoli specificati da Aspose.Imaging.RectangleF strutture.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile delle outlines dei rectangoli.

rects RectangleF [ ]

Array di Aspose.Imaging.RectangleF strutture che rappresentano i rectangoli da disegnare.

Exceptions

ArgumentNullException

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

DrawRectangles(Pen, Rettangolo[])

Disegna una serie di rettangoli specificati da Aspose.Imaging.Rectangle strutture.

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

Parameters

pen Pen

Aspose.Imaging.Pen che determina il colore, la larghezza e lo stile delle outlines dei rectangoli.

rects Rectangle [ ]

Arrivo di Aspose.Imaging.Strutture rettangoli che rappresentano le retangole da disegnare.

Examples

Questo esempio mostra la creazione e l’utilizzo degli oggetti di Pen. L’esempio crea una nuova Immagine e disegna Rectangles sulla superficie dell’Imagine.

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

Inserisci la riga di testo specificata nella posizione specifica con gli oggetti specifici Aspose.Imaging.Brush e W L17.Font.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

x float

Il coordinato x dell’angolo superiore sinistro del testo ritratto.

y float

Il coordinato y dell’angolo superiore a sinistra del testo ritratto.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush e PointF)

Inserisci la riga di testo specificata nella posizione specifica con gli oggetti specifici Aspose.Imaging.Brush e W L17.Font.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

point PointF

Aspose.Imaging.PointF struttura che specifica l’angolo superiore a sinistra del testo ritratto.

Examples

Questo esempio utilizza la classe Graphics per creare forme primitive sulla superficie dell’immagine.Per dimostrare l’operazione, lo esempio crea una nuova Immagine in formato PNG e disegna forme primitive sulla sua superficie utilizzando i metodi di disegno esposti dalla classe Grafica

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

Traccia la riga di testo specificata nella posizione specifica con l’oggetto specifico Aspose.Imaging.Brush e Wl17.Font utilizzando gli attributi di formattazione del specificato __ WL16__ .StringFormat.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

x float

Il coordinato x dell’angolo superiore sinistro del testo ritratto.

y float

Il coordinato y dell’angolo superiore a sinistra del testo ritratto.

format StringFormat

Aspose.Imaging.StringFormat che specifica gli attributi di formattazione, come lo spazzatura di linea e l’allineamento, che vengono applicati al testo ritratto.

Exceptions

ArgumentNullException

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

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

Traccia la riga di testo specificata nella posizione specifica con l’oggetto specifico Aspose.Imaging.Brush e Wl17.Font utilizzando gli attributi di formattazione del specificato __ WL16__ .StringFormat.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

point PointF

Aspose.Imaging.PointF struttura che specifica l’angolo superiore a sinistra del testo ritratto.

format StringFormat

Aspose.Imaging.StringFormat che specifica gli attributi di formattazione, come lo spazzatura di linea e l’allineamento, che vengono applicati al testo ritratto.

Exceptions

ArgumentNullException

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

DrawString(String, Font, Brush, RectangleF)

Traccia la riga di testo specificata nel rettangolo specificato con gli oggetti specificati Aspose.Imaging.Brush e Wl17.Font.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struttura che specifica la posizione del testo ritratto.

Exceptions

ArgumentNullException

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

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

Traccia la riga di testo specificata nella rettangola specifica con l’oggetto specifico Aspose.Imaging.Brush e Wl17.Font utilizzando gli attributi di formattazione dell’atteggiamento specificato __ WL16__ .StringFormat.

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

Parameters

s string

String per disegnare.

font Font

Aspose.Imaging.Fonte che definisce il formato del testo della riga.

brush Brush

Aspose.Imaging.Brush che determina il colore e la texture del testo ritratto.

layoutRectangle RectangleF

Aspose.Imaging.RectangleF struttura che specifica la posizione del testo ritratto.

format StringFormat

Aspose.Imaging.StringFormat che specifica gli attributi di formattazione, come lo spazzatura di linea e l’allineamento, che vengono applicati al testo ritratto.

Exceptions

ArgumentNullException

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

EndUpdate()

Finisce la cattura delle operazioni grafiche iniziate dopo che BeginUpdate è stato chiamato. le operazioni grafiche precedenti saranno applicate all’improvviso quando si chiama questo metodo.

public void EndUpdate()

FillClosedCurve(Gioielli, PointF[])

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.PointF. Questo metodo utilizza una tensione predefinita di 0.5 e __ WL16__..FillMode.Alternate modalità riempimento.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Gioielli, PointF[ ], di FillMode)

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.PointF utilizzando il modo di riempimento specificato. Questo metodo utilizza una tensione predefinita di 0.5.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

fillMode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina come viene compilata la curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(Gioielli, PointF[ ], Il flusso, il flusso)

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.PointF utilizzando la modalità di riempimento e la tensione specificata.

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

Parameters

brush Brush

A Aspose.Imaging.Brush che determina le caratteristiche del riempimento.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che definiscono la spline.

fillmode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina come viene compilata la curva.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(Il punto, il punto[])

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.Point.Questo metodo utilizza una tensione predefinita di 0.5 e W L17.FillMode.Alternate modalità riempimento.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

Exceptions

ArgumentNullException

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

FillClosedCurve(Il punto, il punto[ ], di FillMode)

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.Point utilizzando il modo di riempimento specificato. Questo metodo utilizza una tensione predefinita di 0.5.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

fillmode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina come viene compilata la curva.

Exceptions

ArgumentNullException

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

FillClosedCurve(Il punto, il punto[ ], Il flusso, il flusso)

Riempie l’interno di una curva spline cardinale chiusa definita da una serie di strutture Aspose.Imaging.Point utilizzando il modo di riempimento e tensione specificati.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che definiscono la spline.

fillmode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina come viene compilata la curva.

tension float

Valore superiore o uguale a 0.0F che specifica la tensione della curva.

Exceptions

ArgumentNullException

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

FillEllipse(Spazzolino, RectangleF)

Riempie l’interno di un ellipso definito da un rettangolo di confine specificato da una struttura Aspose.Imaging.RectangleF.

public void FillEllipse(Brush brush, RectangleF rect)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect RectangleF

Aspose.Imaging.RectangleF struttura che rappresenta il rettangolo di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Spazzolino, flotta, flotta, flotta, flotta)

Riempie l’interno di un ellipso definito da un rettangolo di confine specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x float

Il coordinato x dell’angolo superiore a sinistra del rectangolo di confine che definisce l’ellipso.

y float

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso.

width float

La larghezza del rettangolo di confine che definisce l’ellipso.

height float

L’altezza del rectangolo di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

brush’ is null.

FillEllipse(Spazzolino, Rectangle)

Riempie l’interno di un ellipso definito da un rettangolo di confine specificato da una struttura Aspose.Imaging.Rectangle.

public void FillEllipse(Brush brush, Rectangle rect)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect Rectangle

Aspose.Imaging.Struttura retangolare che rappresenta il retango di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

brush’ is null.

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

Riempie l’interno di un ellipso definito da un rettangolo di confine specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x int

Il coordinato x dell’angolo superiore a sinistra del rectangolo di confine che definisce l’ellipso.

y int

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso.

width int

La larghezza del rettangolo di confine che definisce l’ellipso.

height int

L’altezza del rectangolo di confine che definisce l’ellipso.

Exceptions

ArgumentNullException

brush’ is null.

FillPath(Giocattoli, GraphicsPath)

Riempie l’interno di un Aspose.Imaging.GraphicsPath.

public void FillPath(Brush brush, GraphicsPath path)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

path GraphicsPath

Aspose.Imaging.GraficaPath che rappresenta il percorso da compilare.

Exceptions

ArgumentNullException

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

FillPie(Spazzolino, Rectangle, Float, Float)

Riempie l’interno di una sezione piede definita da un ellipso specificato da una struttura Aspose.Imaging.RectangleF e due linee radiali.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect Rectangle

Aspose.Imaging.Struttura retangolare che rappresenta la retanga di confine che definisce l’ellipso da cui proviene la sezione pie.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al primo lato della sezione pie.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ al secondo lato della sezione pie.

Examples

L’esempio seguente mostra come compilare un’immagine GIF animata da singoli blocchi Gif.

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

Riempie l’interno di una sezione piede definita da un ellipso specificato da una struttura Aspose.Imaging.RectangleF e due linee radiali.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect RectangleF

Aspose.Imaging.RectangleF struttura che rappresenta il rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al primo lato della sezione pie.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ al secondo lato della sezione pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPie(Spazzolino, flotta, flotta, flotta, flotta, flotta, flotta)

Riempie l’interno di una sezione di piede definita da un ellipso specificato da un paio di coordinate, una larghezza, una altezza e due linee radiali.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x float

Il coordinato x dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

y float

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

width float

La larghezza del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

height float

L’altezza del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

startAngle float

L’angolo in gradi misurato in modo orario dall’asse x al primo lato della sezione pie.

sweepAngle float

L’angolo in gradi misurato in modo orario dal parametro startAngle’ al secondo lato della sezione pie.

Exceptions

ArgumentNullException

brush’ is null.

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

Riempie l’interno di una sezione di piede definita da un ellipso specificato da un paio di coordinate, una larghezza, una altezza e due linee radiali.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x int

Il coordinato x dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

y int

Il y-coordinato dell’angolo superiore a sinistra del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

width int

La larghezza del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

height int

L’altezza del rettangolo di confine che definisce l’ellipso da cui proviene la sezione pie.

startAngle int

L’angolo in gradi misurato in modo orario dall’asse x al primo lato della sezione pie.

sweepAngle int

L’angolo in gradi misurato in modo orario dal parametro startAngle’ al secondo lato della sezione pie.

Exceptions

ArgumentNullException

brush’ is null.

FillPolygon(Gioielli, PointF[])

Riempie l’interno di un poligono definito da una serie di punti specificati dalle strutture Aspose.Imaging.PointF e __ WL16__ .FillMode.Alternate.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che rappresentano le verticali del poligono da riempire.

Exceptions

ArgumentNullException

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

FillPolygon(Gioielli, PointF[ ], di FillMode)

Riempie l’interno di un poligono definito da una serie di punti specificati dalle strutture Aspose.Imaging.PointF utilizzando il modo di riempimento specificato.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points PointF [ ]

Arrivo di Aspose.Imaging.PointF strutture che rappresentano le verticali del poligono da riempire.

fillMode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina lo stile del riempimento.

Exceptions

ArgumentNullException

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

FillPolygon(Il punto, il punto[])

Riempie l’interno di un poligono definito da una serie di punti specificati da Aspose.Imaging.Strutture di punto e W L17.FillMode.Alternate.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che rappresentano le verticali del poligono da riempire.

Exceptions

ArgumentNullException

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

FillPolygon(Il punto, il punto[ ], di FillMode)

Riempie l’interno di un poligono definito da una serie di punti specificati da Aspose.Imaging.Strutture punti utilizzando il modo di riempimento specificato.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

points Point [ ]

Arrivo di Aspose.Imaging.Strutture di punto che rappresentano le verticali del poligono da riempire.

fillMode FillMode

Membro dell’elenco Aspose.Imaging.FillMode che determina lo stile del riempimento.

Exceptions

ArgumentNullException

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

FillRectangle(Spazzolino, Rectangle)

Riempie l’interno di un rettangolo specificato da una struttura Aspose.Imaging.Rectangle.

public void FillRectangle(Brush brush, Rectangle rect)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect Rectangle

Aspose.Imaging.Struttura rettangolare che rappresenta la retangola da riempire.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Spazzolino, RectangleF)

Riempie l’interno di un rettangolo specificato da una struttura Aspose.Imaging.RectangleF.

public void FillRectangle(Brush brush, RectangleF rect)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rect RectangleF

Aspose.Imaging.RectangleF struttura che rappresenta il rettangolo da riempire.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangle(Spazzolino, flotta, flotta, flotta, flotta)

Riempie l’interno di un rettangolo specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x float

Il coordinato x dell’angolo superiore a sinistra del rectangolo per riempire.

y float

Il coordinato y dell’angolo superiore sinistro del rectangolo per riempire.

width float

La larghezza del rectangolo da riempire.

height float

L’altezza del rectangolo da riempire.

Exceptions

ArgumentNullException

brush’ is null.

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

Riempie l’interno di un rettangolo specificato da un paio di coordinate, una larghezza e una altezza.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

x int

Il coordinato x dell’angolo superiore a sinistra del rectangolo per riempire.

y int

Il coordinato y dell’angolo superiore sinistro del rectangolo per riempire.

width int

La larghezza del rectangolo da riempire.

height int

L’altezza del rectangolo da riempire.

Exceptions

ArgumentNullException

brush’ is null.

FillRectangles(Spazzolino, Rectangle[])

Riempie gli interni di una serie di rettangoli specificati da Aspose.Imaging.Rectangle strutture.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rects Rectangle [ ]

Array di Aspose.Imaging.Rectangle strutture che rappresentano i rectangoli da riempire.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRectangles(Spazzolino, RectangleF[])

Riempie gli interni di una serie di rettangoli specificati da Aspose.Imaging.RectangleF strutture.

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

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

rects RectangleF [ ]

Array di Aspose.Imaging.Rectangle strutture che rappresentano i rectangoli da riempire.

Exceptions

ArgumentNullException

brush’ is null or rects’ is null.

FillRegion(Brush, Regione)

Riempie l’interno di una Aspose.Imaging.Regione.

public void FillRegion(Brush brush, Region region)

Parameters

brush Brush

WL17_.Brush che determina le caratteristiche del riempimento.

region Region

Aspose.Imaging.Regione che rappresenta l’area da compilare.

Exceptions

ArgumentNullException

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

~Graphics()

protected ~Graphics()

MeasureString(string, font, SizeF, StringFormat)

misura la riga di testo specifica con parametri specifici

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

Parameters

text string

Il testo da misurare.

font Font

Il font da misurare.

layoutArea SizeF

La zona di layout.

stringFormat StringFormat

Il formato string.

Returns

SizeF

dimensioni in pixel di stringhe di testo misurate

MultiplyTransform(Matrix)

Moltiplica il Aspose.Imaging.Matrix che rappresenta la trasformazione geometrica locale di questo Wl17.Grafica per il specificato wl 17 .Matrx prependendo il specifico _ wl7__..

public void MultiplyTransform(Matrix matrix)

Parameters

matrix Matrix

Il Aspose.Imaging.Matrix da cui moltiplicare la trasformazione geometrica.

MultiplyTransform(di Matrix, MatrixOrder)

Moltiplica il Aspose.Imaging.Matrix che rappresenta la trasformazione geometrica locale di questo WR17.Grafica per il specificato _ WR18_ .Matrx nell’ordine specifico.

public void MultiplyTransform(Matrix matrix, MatrixOrder order)

Parameters

matrix Matrix

Il Aspose.Imaging.Matrix da cui moltiplicare la trasformazione geometrica.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder che specifica in quale scopo moltiplicare le due matrice.

ResetTransform()

Ripristina il Aspose.Imaging.Graphics.Transformare la proprietà in identità.

public void ResetTransform()

RotateTransform(flotta)

Rota la trasformazione geometrica locale per la quantità specificata.Questo metodo preende la rotazione alla trasformazione.

public void RotateTransform(float angle)

Parameters

angle float

L’angolo della rotazione.

RotateTransform(Sviluppo, MatrixOrder)

Rota la trasformazione geometrica locale per la quantità specificata nell’ordine specificato.

public void RotateTransform(float angle, MatrixOrder order)

Parameters

angle float

L’angolo della rotazione.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder che specifica se aggiungere o prependere la matrice di rotazione.

ScaleTransform(La flotta, la flotta)

Scalare la trasformazione geometrica locale per le quantità specificate.Questo metodo preende la matrice di scalazione alla trasformazione.

public void ScaleTransform(float sx, float sy)

Parameters

sx float

La quantità per la quale scalare la trasformazione nella direzione x-axis.

sy float

La quantità per la quale scalare la trasformazione nella direzione y-axis.

ScaleTransform(Il flusso, il flusso, MatrixOrder)

Scalare la trasformazione geometrica locale per le quantità specificate nell’ordine specificato.

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

Parameters

sx float

La quantità per la quale scalare la trasformazione nella direzione x-axis.

sy float

La quantità per la quale scalare la trasformazione nella direzione y-axis.

order MatrixOrder

Un Aspose.Imaging.MatrixOrder che specifica se aggiungere o prependere la matrice di scala.

TranslateTransform(La flotta, la flotta)

Traduzione della trasformazione geometrica locale per le dimensioni specificate.Questo metodo impone la traduzione alla trasformazione.

public void TranslateTransform(float dx, float dy)

Parameters

dx float

Il valore della traduzione in x.

dy float

Il valore della traduzione in y.

TranslateTransform(Il flusso, il flusso, MatrixOrder)

Traduzione della trasformazione geometrica locale per le dimensioni specificate nell’ordine specificato.

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

Parameters

dx float

Il valore della traduzione in x.

dy float

Il valore della traduzione in y.

order MatrixOrder

L’ordine (prepend o append) in cui applicare la traduzione.

 Italiano