Class SvgGraphics2D

Class SvgGraphics2D

İsim alanı : Aspose.Imaging.FileFormats.Svg.Graphics Toplantı: Aspose.Imaging.dll (25.4.0)

Bir Svg görüntüsünü oluşturmak için komutları çizmeyi sağlar.

public class SvgGraphics2D

Inheritance

object SvgGraphics2D

mirasçı üyeleri

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

Constructors

Grafik 2D(int , int , int , int)

Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D sınıfının yeni bir örneğini başlatır.

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

Parameters

width int

Sonuç SVG görüntü genişliği.

height int

Sonuç SVG görüntü genişliği.

dpi int

Cihazın çözünürlüğü, örneğin inç başına 96 nokta.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve PNG’ye nasıl rasterize edeceğinizi gösterir.

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");
                                                                                                       }

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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");
                                                                                                                                   }

Grafik 2D(SvgImage)

Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D sınıfının yeni bir örneğini başlatır.

public SvgGraphics2D(SvgImage image)

Parameters

image SvgImage

Görüntü üzerinde çizim operasyonları gerçekleştirmek için.

Methods

DrawArc(Yüzük, Yüzük, Yüzük, Yüzük)

Bir rektangle yapısı tarafından belirlenen bir elipsin bir kısmını temsil eden bir çubuk çizilir.

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

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

rect Rectangle

Ellipse’nin sınırları

startAngle float

Derecelerde açı x-axis’ten arkanın başlangıç noktasına kadar saatlik olarak ölçülmüştür.

arcAngle float

Derecelerde açı, başlangıç parametresinden arkanın noktasının sonuna kadar saatlik olarak ölçülür.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

DrawCubicBezier(Pen, PointF, PointF ve PointF)

Kubik Bezier’i kullanın.

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

Parameters

pen Pen

Şekilin rengi, genişliği ve tarzını belirleyen kalem.

pt1 PointF

Kurşun başlangıç noktasıdır.

pt2 PointF

Kurşun için ilk kontrol noktası.

pt3 PointF

İkinci kontrol noktası kurşun için.

pt4 PointF

Sırtın son noktasıdır.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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(RasterImage ve Nokta)

Belirlenen görüntüyi belirlenen konumda kaydedin.

public void DrawImage(RasterImage image, Point origin)

Parameters

image RasterImage

Çekilmiş görüntü.

origin Point

Çekilen resmin yeri.

DrawImage(RasterImage, Nokta, Boyut)

Belirlenmiş konumda belirtilen boyutun belirlenmiş görüntüsünü çizin.

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

Parameters

image RasterImage

Çekilmiş görüntü.

origin Point

Çekilen resmin yeri.

size Size

İstediğiniz görüntü boyutu.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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 ve RasterImage)

Belirlenen resmin belirlenmiş kısmını belirlenmiş konumda ve belirlenmiş boyutta çizin.

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

Parameters

srcRect Rectangle

Görüntü nesnesinin çizim kısmı.

destRect Rectangle

Görüntünün konumu ve büyüklüğü. görüntü düz açıya uygun olarak ölçülür.

image RasterImage

Çekmek için resim.

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

çizgiyi sürükle.

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

Parameters

pen Pen

Şekilin rengi, genişliği ve tarzını belirleyen kalem.

x1 int

Birinci noktanın x-koordinasyonu

y1 int

Birinci noktanın y-koordinasyonu

x2 int

İkinci noktanın x koordinasyonu.

y2 int

İkinci noktanın y-koordinasyonu

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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(Çerçeve, Grafik)

Yolunu sürükle.

public void DrawPath(Pen pen, GraphicsPath path)

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

path GraphicsPath

Çekmek için bir yol.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Yüzü düzleştirin.

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

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

x int

Çekmek için düzlemin sol üst köşesinin x-koordinasyonu.

y int

Y-koordinasyonu çizmek için sağ üst köşedeki üst-sol köşede.

width int

Çekmek için düz açı genişliği.

height int

Çekmek için düzlemin yüksekliği.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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(Şekil, çizgi, nokta, renk)

Yazı çubuğunu çizin.

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

Parameters

font Font

Yazıyı yazmak için kullanılan yazı tipi.

text string

Unicode metin çubuğu.

origin Point

Yazının sol üst köşesi çalışıyor.

textColor Color

Yazının rengi.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D aracılığıyla gerçekleştirilen tüm çizim komutlarını içeren son Svg görüntüsünü alır.

public SvgImage EndRecording()

Returns

SvgImage

SGG’nin son görüntüsü.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FillArc(Pen, fırça, rektangle, float, float)

Bir rektangle yapısı tarafından belirlenen bir elipsin bir kısmını temsil eden bir çubuk doldurur.

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

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

brush Brush

Şekil içini doldurmak için fırça.

rect Rectangle

Ellipse’nin sınırları

startAngle float

Derecelerde açı x-axis’ten arkanın başlangıç noktasına kadar saatlik olarak ölçülmüştür.

arcAngle float

Derecelerde açı, başlangıç parametresinden arkanın noktasının sonuna kadar saatlik olarak ölçülür.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FillPath(Pen, fırça, GraphicsPath)

Yolu doldurmak için.

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

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

brush Brush

Şekil içini doldurmak için fırça.

path GraphicsPath

Çekmek için bir yol.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Doğrudan doldurulur.

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

Parameters

pen Pen

Şekilin çıkışını çizmek için kalem.

brush Brush

Şekil içini doldurmak için fırça.

x int

Çekmek için düzlemin sol üst köşesinin x-koordinasyonu.

y int

Y-koordinasyonu çizmek için sağ üst köşedeki üst-sol köşede.

width int

Çekmek için düz açı genişliği.

height int

Çekmek için düzlemin yüksekliği.

Examples

Bu örnek, belirli boyutlu bir SVG görüntüsünü nasıl oluşturacağınızı ve SvgGraphics2D’yi kullanarak farklı şekiller çizeceğinizi gösterir.

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");
                                                                                                                                   }
 Türkçe