Class SvgGraphics2D

Class SvgGraphics2D

Nama dari : Aspose.Imaging.FileFormats.Svg.Graphics Pengumpulan: Aspose.Imaging.dll (25.4.0)

Memungkinkan menggambar komando untuk menyusun gambar Svg.

public class SvgGraphics2D

Inheritance

object SvgGraphics2D

anggota yang diwarisi

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

Constructors

Perbedaan grafis2D(int, int, int dan int)

Initifikasi contoh baru dari Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D kelas.

public SvgGraphics2D(int width, int height, int dpi)

Parameters

width int

Ketebalan gambar output Svg.

height int

Ketebalan gambar output Svg.

dpi int

Resolusi perangkat, misalnya 96 titik per inci.

Examples

Contoh ini menunjukkan bagaimana untuk membuat gambar SVG dari ukuran yang ditentukan dan rasterize ke PNG.

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

                                                                                                       int imageWidth = 100;
                                                                                                       int imageHeight = 100;
                                                                                                       int dpi = 96;

                                                                                                       // Create an SVG image of 100x100 px.
                                                                                                       Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                       Aspose.Imaging.Pen pen = new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 10);
                                                                                                       Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                       // Fill the entire image in red.
                                                                                                       // Draw a yellow rectangle of 10px wide along the image boundaries.
                                                                                                       graphics.FillRectangle(pen, brush, 0, 0, imageWidth, imageHeight);

                                                                                                       // Get the final Svg image which includes all drawing commands
                                                                                                       using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                       {
                                                                                                           svgImage.Save(dir + "test.output.svg");
                                                                                                       }

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

Perbedaan grafis2D(SvgImage)

Initifikasi contoh baru dari Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D kelas.

public SvgGraphics2D(SvgImage image)

Parameters

image SvgImage

Gambar untuk melakukan operasi lukisan.

Methods

DrawArc(Pen, rektangle, float, float)

Ia menggambarkan arc yang mewakili bagian dari ellipse yang ditentukan oleh struktur rektangle.

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

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

rect Rectangle

Perbatasan dari Ellipse

startAngle float

Sudut dalam derajat diukur dengan cara jam dari x-axis ke titik permulaan arc.

arcAngle float

Sudut dalam derajat diukur dengan cara jam dari parameter startAngle sampai titik akhir arc.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

DrawCubicBezier(Pen, PointF, PointF dan PointF)

Menarik dari kubik bezier.

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

Parameters

pen Pen

Pen yang menentukan warna, lebar, dan gaya angka.

pt1 PointF

titik awal dari kurva.

pt2 PointF

Titik kontrol pertama untuk kurva.

pt3 PointF

Titik kontrol kedua untuk kurva.

pt4 PointF

titik akhir dari kurva.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

DrawImage(Perbedaan, Point)

Menarik gambar yang ditentukan di lokasi yang ditentukan.

public void DrawImage(RasterImage image, Point origin)

Parameters

image RasterImage

Gambar yang dicetak.

origin Point

Lokasi gambar yang ditarik.

DrawImage(RasterImage, titik, ukuran)

Menarik gambar yang ditentukan dari ukuran yang ditentukan di lokasi yang ditentukan.

public void DrawImage(RasterImage image, Point origin, Size size)

Parameters

image RasterImage

Gambar yang dicetak.

origin Point

Lokasi gambar yang ditarik.

size Size

Ukuran yang diinginkan dari gambar.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

DrawImage(Rectangle, Rectangle dan RasterImage)

Menarik bagian yang ditentukan dari gambar yang ditentukan di lokasi yang ditentukan dan dengan ukuran yang ditentukan.

public void DrawImage(Rectangle srcRect, Rectangle destRect, RasterImage image)

Parameters

srcRect Rectangle

Sebagian dari gambar objek untuk dicetak.

destRect Rectangle

Lokasi dan ukuran gambar yang ditarik.Gambar ini dikelompokkan untuk menyesuaikan rektangle.

image RasterImage

Gambar yang harus dicetak.

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

menggerakkan garis tersebut.

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

Parameters

pen Pen

Pen yang menentukan warna, lebar, dan gaya angka.

x1 int

Koordinat x dari titik pertama.

y1 int

koordinat dari titik pertama.

x2 int

Koordinat X dari titik kedua.

y2 int

koordinat dari titik kedua.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

DrawPath(Pen dan GraphicsPath)

menggerakkan jalan.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

path GraphicsPath

Jalan untuk menggambar.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

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

menggerakkan rektangle.

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

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

x int

Koordinat x dari sudut kiri atas rektangul untuk dicetak.

y int

Y-koordinat sudut kiri atas rektangul untuk dicetak.

width int

Ketebalan rektangul untuk dicetak.

height int

Ketinggian rektangle untuk dicetak.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

DrawString(huruf, string, titik, warna)

Mengalihkan string teks.

public void DrawString(Font font, string text, Point origin, Color textColor)

Parameters

font Font

Fitur yang digunakan untuk membuat teks.

text string

Unicode adalah string teks.

origin Point

sudut kiri atas teks berjalan.

textColor Color

warna teks tersebut.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

EndRecording()

Dapatkan gambar terakhir Svg yang mencakup semua perintah menggambar yang dilakukan melalui Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D object.

public SvgImage EndRecording()

Returns

SvgImage

Gambar terakhir dari Svg.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

FillArc(Pen, Brush, rektangle, float, float)

Mengisi arc yang mewakili bagian dari ellipse yang ditentukan oleh struktur rektangle.

public void FillArc(Pen pen, Brush brush, Rectangle rect, float startAngle, float arcAngle)

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

brush Brush

Pisau untuk mengisi bagian dalam gambar.

rect Rectangle

Perbatasan dari Ellipse

startAngle float

Sudut dalam derajat diukur dengan cara jam dari x-axis ke titik permulaan arc.

arcAngle float

Sudut dalam derajat diukur dengan cara jam dari parameter startAngle sampai titik akhir arc.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

FillPath(Pen, Perisai, GraphicsPath)

mengisi jalur tersebut.

public void FillPath(Pen pen, Brush brush, GraphicsPath path)

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

brush Brush

Pisau untuk mengisi bagian dalam gambar.

path GraphicsPath

Jalan untuk menggambar.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }

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

mengisi rektangle.

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

Parameters

pen Pen

Pen untuk menggambar outline dari angka.

brush Brush

Pisau untuk mengisi bagian dalam gambar.

x int

Koordinat x dari sudut kiri atas rektangul untuk dicetak.

y int

Y-koordinat sudut kiri atas rektangul untuk dicetak.

width int

Ketebalan rektangul untuk dicetak.

height int

Ketinggian rektangle untuk dicetak.

Examples

Contoh ini menunjukkan cara membuat gambar SVG dari ukuran yang ditentukan dan menggambar bentuk yang berbeda di atasnya menggunakan SvgGraphics2D.

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

                                                                                                                                   int imageWidth = 600;
                                                                                                                                   int imageHeight = 400;
                                                                                                                                   int dpi = 96;

                                                                                                                                   Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(imageWidth, imageHeight, dpi);

                                                                                                                                   // Draw a black rectangle along the image borders using a 1-pixel-wide black pen.
                                                                                                                                   graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 1), 0, 0, imageWidth, imageHeight);

                                                                                                                                   // Fill a rectangle with the color of white-smoke.
                                                                                                                                   graphics.FillRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.WhiteSmoke, 1), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.WhiteSmoke), 10, 10, 580, 380);

                                                                                                                                   // Draw two diagonal lines using a 1-pixel-wide darkgreen pen.
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, 0, imageWidth, imageHeight);
                                                                                                                                   graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.DarkGreen, 1), 0, imageHeight, imageWidth, 0);

                                                                                                                                   // Draw an arc within the rectangle {0, 0, 200, 200} using a 2-pixel-wide blue pen.
                                                                                                                                   graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Rectangle(0, 0, 200, 200), 90, 270);

                                                                                                                                   // Fill an arc
                                                                                                                                   graphics.FillArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.LightCoral, 10), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.LightSkyBlue), new Aspose.Imaging.Rectangle(0, 0, 150, 150), 90, 270);

                                                                                                                                   // Draw a cubic bezier using a 2-pixel-wide red pen.
                                                                                                                                   graphics.DrawCubicBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2),
                                                                                                                                       new Aspose.Imaging.PointF(0, 0),
                                                                                                                                       new Aspose.Imaging.PointF(200, 133),
                                                                                                                                       new Aspose.Imaging.PointF(400, 166),
                                                                                                                                       new Aspose.Imaging.PointF(600, 400));

                                                                                                                                   // Draw a raster image of the specified size at the specified location.
                                                                                                                                   // The image is scaled to fit the desired rectangle.
                                                                                                                                   using (Aspose.Imaging.RasterImage imageToDraw = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                   {
                                                                                                                                       graphics.DrawImage(imageToDraw, new Aspose.Imaging.Point(400, 200), new Aspose.Imaging.Size(100, 50));
                                                                                                                                   }

                                                                                                                                   // Draw a text string
                                                                                                                                   graphics.DrawString(new Aspose.Imaging.Font("Arial", 48, Aspose.Imaging.FontStyle.Regular), "Hello World!", new Aspose.Imaging.Point(200, 300), Aspose.Imaging.Color.DarkRed);

                                                                                                                                   // Create a path to fill
                                                                                                                                   Aspose.Imaging.Figure figureToFill = new Aspose.Imaging.Figure();
                                                                                                                                   figureToFill.IsClosed = true;

                                                                                                                                   Aspose.Imaging.GraphicsPath pathToFill = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   pathToFill.AddFigure(figureToFill);

                                                                                                                                   figureToFill.AddShapes(new Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.Rectangle(400, 0, 200, 100), 45, 300),
                                                                                                                                           new Aspose.Imaging.Shapes.BezierShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(400, 200),
                                                                                                                                                   new Aspose.Imaging.PointF(500, 100),
                                                                                                                                                   new Aspose.Imaging.PointF(600, 200),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.PolygonShape(
                                                                                                                                               new Aspose.Imaging.PointF[]
                                                                                                                                               {
                                                                                                                                                   new Aspose.Imaging.PointF(300, 100),
                                                                                                                                               }),
                                                                                                                                           new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(0, 100, 200, 200)),
                                                                                                                                       });

                                                                                                                                   // Fill the path using a yellow brush and a green pen to draw outline
                                                                                                                                   graphics.FillPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Yellow), pathToFill);

                                                                                                                                   // Create a path to draw
                                                                                                                                   Aspose.Imaging.GraphicsPath pathToDraw = new Aspose.Imaging.GraphicsPath();
                                                                                                                                   Aspose.Imaging.Figure figureToDraw = new Aspose.Imaging.Figure();
                                                                                                                                   pathToDraw.AddFigure(figureToDraw);

                                                                                                                                   figureToDraw.AddShapes(new Aspose.Imaging.Shape[]
                                                                                                                                       {
                                                                                                                                           new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(200, 200, 200, 200), 0, 360),
                                                                                                                                       });

                                                                                                                                   // Draw the path using a 5-pixel-wide orange pen.
                                                                                                                                   graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 5), pathToDraw);

                                                                                                                                   // Get the final SVG image which includes all drawing commands
                                                                                                                                   using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = graphics.EndRecording())
                                                                                                                                   {
                                                                                                                                       svgImage.Save(dir + "test.output.svg");
                                                                                                                                   }
 Indonesia