Class SvgGraphics2D

Class SvgGraphics2D

اسم الفضاء : Aspose.Imaging.FileFormats.Svg.Graphics تجميع: Aspose.Imaging.dll (25.4.0)

يتيح رسم الروايات لتكوين صورة Svg.

public class SvgGraphics2D

Inheritance

object SvgGraphics2D

الأعضاء الموروثين

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

Constructors

مجلد2D(إنت، إنت، إنت)

يبدأ مثال جديد من فئة Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D.

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

Parameters

width int

عرض الصورة الخروج Svg.

height int

عرض الصورة الخروج Svg.

dpi int

الضوء، على سبيل المثال 96 نقطة لكل بوصة.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد وتحويلها إلى 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");
                                                                                                       }

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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");
                                                                                                                                   }

مجلد2D(SvgImage)

يبدأ مثال جديد من فئة Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D.

public SvgGraphics2D(SvgImage image)

Parameters

image SvgImage

الصورة لتنفيذ عمليات الرسم على.

Methods

DrawArc(قوس قزح، قوس قزح، قوس قزح)

يقطع قوسًا يمثل جزءًا من الانحناء المحدد من قبل هيكل مستطيل.

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

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

rect Rectangle

الحدود في الإليبس.

startAngle float

يتم قياس الزاوية في الدرجات على طول الساعة من محور x إلى نقطة البداية من القوس.

arcAngle float

يتم قياس الزاوية في الدرجات على مدار الساعة من المقياس البدءالزاوية إلى النهاية نقطة القوس.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(نقطة، نقطة، نقطة، نقطة، نقطة)

أضف تعليق حول CUBIC BEZIEER

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

Parameters

pen Pen

القلم الذي يحدد اللون، وعرض، وأسلوب الشكل.

pt1 PointF

نقطة انطلاق من المنحنى.

pt2 PointF

نقطة التحكم الأولى للمدينة.

pt3 PointF

النقطة الثانية للتحكم في المنحنى.

pt4 PointF

نقطة الانتهاء من المنحنى.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(النقطة، نقطة)

سحب الصورة المحددة في الموقع المحدد.

public void DrawImage(RasterImage image, Point origin)

Parameters

image RasterImage

الصورة المطروحة .

origin Point

موقع الصورة المسجلة.

DrawImage(النقطة، النقطة، حجم)

سحب الصورة المحددة من الحجم المحدد في الموقع المحدد.

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

Parameters

image RasterImage

الصورة المطروحة .

origin Point

موقع الصورة المسجلة.

size Size

الحجم المطلوب للصورة المسجلة.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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 ، RasterImage)

سحب الجزء المحدد من الصورة المحددة في الموقع المحدد ومع الحجم المحدد.

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

Parameters

srcRect Rectangle

الجزء من الصورة الموضوع للطباعة.

destRect Rectangle

موقع وحجم الصورة المسجلة.يتم تقسيم الصورة لتناسب المستطيل.

image RasterImage

الصورة التي يجب رسمها

DrawLine(إنت، إنت، إنت، إنت، إنت)

قم بتحريك الخط

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

Parameters

pen Pen

القلم الذي يحدد اللون، وعرض، وأسلوب الشكل.

x1 int

منسقة X من النقطة الأولى.

y1 int

منسقة النقطة الأولى.

x2 int

منسقة X من النقطة الثانية.

y2 int

منسقة النقطة الثانية.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(الرسوم البيانية, GraphicsPath)

ارفع الطريق .

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

path GraphicsPath

الطريق إلى الرسم.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(إنت، إنت، إنت، إنت، إنت)

قم بتحريك المستطيل.

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

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

x int

منسقة x من الزاوية العليا اليسرى من المستطيل للطباعة.

y int

ي-منسق الزاوية العليا اليسرى من المستطيل لالتقاط.

width int

عرض المستطيل للطباعة.

height int

الارتفاع من المستطيل للطباعة.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(الخط، الحبل، النقطة، اللون)

قم بتحريك شريط النص.

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

Parameters

font Font

الحروف المستخدمة لتقديم النص.

text string

شريط النص الوحيد

origin Point

الجانب الأيسر العلوي من النص يعمل.

textColor Color

لون النص .

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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()

يحصل على الصورة النهائية Svg التي تشمل جميع أوامر الرسم التي يتم تنفيذها من خلال Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D الكائن.

public SvgImage EndRecording()

Returns

SvgImage

الصورة النهائية لـ Svg.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(قضيب، قضيب، قضيب، قضيب)

يملأ قوسًا يمثل جزءًا من الانحناء المحدد من قبل هيكل مستطيل.

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

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

brush Brush

الحلاقة لملء الداخلي للشكل.

rect Rectangle

الحدود في الإليبس.

startAngle float

يتم قياس الزاوية في الدرجات على طول الساعة من محور x إلى نقطة البداية من القوس.

arcAngle float

يتم قياس الزاوية في الدرجات على مدار الساعة من المقياس البدءالزاوية إلى النهاية نقطة القوس.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(القلم، القلم، GraphicsPath)

يملأ الطريق .

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

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

brush Brush

الحلاقة لملء الداخلي للشكل.

path GraphicsPath

الطريق إلى الرسم.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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(القلم، القلم، int، int، int، int)

يملأ المستطيل .

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

Parameters

pen Pen

القلم لتوضيح الخروج من الصورة.

brush Brush

الحلاقة لملء الداخلي للشكل.

x int

منسقة x من الزاوية العليا اليسرى من المستطيل للطباعة.

y int

ي-منسق الزاوية العليا اليسرى من المستطيل لالتقاط.

width int

عرض المستطيل للطباعة.

height int

الارتفاع من المستطيل للطباعة.

Examples

هذا المثال يظهر كيفية إنشاء صورة SVG من الحجم المحدد و رسم أشكال مختلفة عليها باستخدام 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");
                                                                                                                                   }
 عربي