Class VectorRasterizationOptions

Class VectorRasterizationOptions

Namespace: Aspose.Imaging.ImageOptions
Assembly: Aspose.Imaging.dll (25.2.0)

The vector rasterization options. Please note that Aspose.Imaging.ImageOptions.VectorRasterizationOptions will no longer derive from Aspose.Imaging.ImageOptionsBase since Aspose.Imaging 24.12 version.

[JsonObject(MemberSerialization.OptIn)]
public class VectorRasterizationOptions : ImageOptionsBase, IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inheritance

objectDisposableObjectImageOptionsBaseVectorRasterizationOptions

Derived

CdrRasterizationOptions, CmxRasterizationOptions, EpsRasterizationOptions, MetafileRasterizationOptions, OdRasterizationOptions, SvgRasterizationOptions

Implements

IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inherited Members

ImageOptionsBase.Clone(), ImageOptionsBase.ReleaseManagedResources(), ImageOptionsBase.KeepMetadata, ImageOptionsBase.XmpData, ImageOptionsBase.Source, ImageOptionsBase.Palette, ImageOptionsBase.ResolutionSettings, ImageOptionsBase.VectorRasterizationOptions, ImageOptionsBase.BufferSizeHint, ImageOptionsBase.MultiPageOptions, ImageOptionsBase.FullFrame, ImageOptionsBase.ProgressEventHandler, DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Constructors

VectorRasterizationOptions()

public VectorRasterizationOptions()

Properties

BackgroundColor

Gets or sets a background color.

[JsonProperty]
public Color BackgroundColor { get; set; }

Property Value

Color

Examples

This example shows how to load a WMF image from a file and convert it to SVG using WmfRasterizationOptions.```csharp [C#]

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

                                                                                                                  // Using Aspose.Imaging.Image.Load is a unified way to load all types of images including WMF.
                                                                                                                  using (Aspose.Imaging.FileFormats.Wmf.WmfImage wmfImage = (Aspose.Imaging.FileFormats.Wmf.WmfImage)Aspose.Imaging.Image.Load(dir + "test.wmf"))
                                                                                                                  {
                                                                                                                      Aspose.Imaging.ImageOptions.SvgOptions saveOptions = new Aspose.Imaging.ImageOptions.SvgOptions();

                                                                                                                      // Text will be converted to shapes.
                                                                                                                      saveOptions.TextAsShapes = true;

                                                                                                                      Aspose.Imaging.ImageOptions.WmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.WmfRasterizationOptions();

                                                                                                                      // The background color of the drawing surface.
                                                                                                                      rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.WhiteSmoke;

                                                                                                                      // The page size.
                                                                                                                      rasterizationOptions.PageSize = wmfImage.Size;

                                                                                                                      // If embedded emf exists, then render emf; otherwise render wmf.
                                                                                                                      rasterizationOptions.RenderMode = Aspose.Imaging.FileFormats.Wmf.WmfRenderMode.Auto;

                                                                                                                      saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                      wmfImage.Save(dir + "test.output.svg", saveOptions);
                                                                                                                  }

This example shows how to load a EMF image from a file and convert it to SVG using EmfRasterizationOptions.```csharp
[C#]

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

                                                                                                                      // Using Aspose.Imaging.Image.Load is a unified way to load all types of images including EMF.
                                                                                                                      using (Aspose.Imaging.FileFormats.Emf.EmfImage emfImage = (Aspose.Imaging.FileFormats.Emf.EmfImage)Aspose.Imaging.Image.Load(dir + "test.emf"))
                                                                                                                      {
                                                                                                                          Aspose.Imaging.ImageOptions.SvgOptions saveOptions = new Aspose.Imaging.ImageOptions.SvgOptions();

                                                                                                                          // Text will be converted to shapes.
                                                                                                                          saveOptions.TextAsShapes = true;

                                                                                                                          Aspose.Imaging.ImageOptions.EmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.EmfRasterizationOptions();

                                                                                                                          // The background color of the drawing surface.
                                                                                                                          rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.WhiteSmoke;

                                                                                                                          // The page size.
                                                                                                                          rasterizationOptions.PageSize = emfImage.Size;

                                                                                                                          // If embedded emf exists, then render emf; otherwise render wmf.
                                                                                                                          rasterizationOptions.RenderMode = Aspose.Imaging.FileFormats.Emf.EmfRenderMode.Auto;

                                                                                                                          // Set the horizontal margin
                                                                                                                          rasterizationOptions.BorderX = 50;

                                                                                                                          // Set the vertical margin
                                                                                                                          rasterizationOptions.BorderY = 50;

                                                                                                                          saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                          emfImage.Save(dir + "test.output.svg", saveOptions);
                                                                                                                      }

This example shows how to load an SVG image from a file and rasterize it to PNG using various options.```csharp [C#]

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

                                                                                                             // Using Aspose.Imaging.Image.Load is a unified way to load image.
                                                                                                             using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = (Aspose.Imaging.FileFormats.Svg.SvgImage)Aspose.Imaging.Image.Load(dir + "test.svg"))
                                                                                                             {
                                                                                                                 // In order to rasterize SVG we need to specify rasterization options.
                                                                                                                 Aspose.Imaging.ImageOptions.SvgRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.SvgRasterizationOptions();

                                                                                                                 // Set default color of a background for an image. Default value is white.
                                                                                                                 rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.Gray;

                                                                                                                 // Set the page size
                                                                                                                 rasterizationOptions.PageSize = svgImage.Size;

                                                                                                                 // Antialiasing is applied to lines and curves and the edges of filled areas.
                                                                                                                 rasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.AntiAlias;

                                                                                                                 // Each character is drawn using its antialiased glyph bitmap without hinting.
                                                                                                                 rasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.AntiAlias;

                                                                                                                 // Reduce the image size 10 times, i.e. the output size will be 10% of the original size.
                                                                                                                 rasterizationOptions.ScaleX = 0.1f;
                                                                                                                 rasterizationOptions.ScaleY = 0.1f;

                                                                                                                 Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                 saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                 // Save to a PNG file
                                                                                                                 svgImage.Save(dir + "test.output.png", saveOptions);
                                                                                                             }

### <a id="Aspose_Imaging_ImageOptions_VectorRasterizationOptions_BorderX"></a> BorderX

Gets or sets the border X.

```csharp
[JsonProperty]
public float BorderX { get; set; }

Property Value

float

BorderY

Gets or sets the border Y.

[JsonProperty]
public float BorderY { get; set; }

Property Value

float

CenterDrawing

Gets or sets a value indicating whether center drawing.

[JsonProperty]
public bool CenterDrawing { get; set; }

Property Value

bool

DrawColor

Gets or sets a foreground color.

[JsonProperty]
public Color DrawColor { get; set; }

Property Value

Color

PageHeight

Gets or sets the page height. If the value is 0, the source image aspect ratio will be preserved.

public float PageHeight { get; set; }

Property Value

float

PageSize

Gets or sets the page size. If one of Aspose.Imaging.SizeF dimensions is 0, the source image aspect ratio will be preserved.

public SizeF PageSize { get; set; }

Property Value

SizeF

Examples

This example shows how to load a WMF image from a file and convert it to SVG using WmfRasterizationOptions.```csharp [C#]

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

                                                                                                                  // Using Aspose.Imaging.Image.Load is a unified way to load all types of images including WMF.
                                                                                                                  using (Aspose.Imaging.FileFormats.Wmf.WmfImage wmfImage = (Aspose.Imaging.FileFormats.Wmf.WmfImage)Aspose.Imaging.Image.Load(dir + "test.wmf"))
                                                                                                                  {
                                                                                                                      Aspose.Imaging.ImageOptions.SvgOptions saveOptions = new Aspose.Imaging.ImageOptions.SvgOptions();

                                                                                                                      // Text will be converted to shapes.
                                                                                                                      saveOptions.TextAsShapes = true;

                                                                                                                      Aspose.Imaging.ImageOptions.WmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.WmfRasterizationOptions();

                                                                                                                      // The background color of the drawing surface.
                                                                                                                      rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.WhiteSmoke;

                                                                                                                      // The page size.
                                                                                                                      rasterizationOptions.PageSize = wmfImage.Size;

                                                                                                                      // If embedded emf exists, then render emf; otherwise render wmf.
                                                                                                                      rasterizationOptions.RenderMode = Aspose.Imaging.FileFormats.Wmf.WmfRenderMode.Auto;

                                                                                                                      saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                      wmfImage.Save(dir + "test.output.svg", saveOptions);
                                                                                                                  }

This example shows how to load a EMF image from a file and convert it to SVG using EmfRasterizationOptions.```csharp
[C#]

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

                                                                                                                      // Using Aspose.Imaging.Image.Load is a unified way to load all types of images including EMF.
                                                                                                                      using (Aspose.Imaging.FileFormats.Emf.EmfImage emfImage = (Aspose.Imaging.FileFormats.Emf.EmfImage)Aspose.Imaging.Image.Load(dir + "test.emf"))
                                                                                                                      {
                                                                                                                          Aspose.Imaging.ImageOptions.SvgOptions saveOptions = new Aspose.Imaging.ImageOptions.SvgOptions();

                                                                                                                          // Text will be converted to shapes.
                                                                                                                          saveOptions.TextAsShapes = true;

                                                                                                                          Aspose.Imaging.ImageOptions.EmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.EmfRasterizationOptions();

                                                                                                                          // The background color of the drawing surface.
                                                                                                                          rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.WhiteSmoke;

                                                                                                                          // The page size.
                                                                                                                          rasterizationOptions.PageSize = emfImage.Size;

                                                                                                                          // If embedded emf exists, then render emf; otherwise render wmf.
                                                                                                                          rasterizationOptions.RenderMode = Aspose.Imaging.FileFormats.Emf.EmfRenderMode.Auto;

                                                                                                                          // Set the horizontal margin
                                                                                                                          rasterizationOptions.BorderX = 50;

                                                                                                                          // Set the vertical margin
                                                                                                                          rasterizationOptions.BorderY = 50;

                                                                                                                          saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                          emfImage.Save(dir + "test.output.svg", saveOptions);
                                                                                                                      }

This example shows how to load an SVG image from a file and rasterize it to PNG using various options.```csharp [C#]

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

                                                                                                             // Using Aspose.Imaging.Image.Load is a unified way to load image.
                                                                                                             using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = (Aspose.Imaging.FileFormats.Svg.SvgImage)Aspose.Imaging.Image.Load(dir + "test.svg"))
                                                                                                             {
                                                                                                                 // In order to rasterize SVG we need to specify rasterization options.
                                                                                                                 Aspose.Imaging.ImageOptions.SvgRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.SvgRasterizationOptions();

                                                                                                                 // Set default color of a background for an image. Default value is white.
                                                                                                                 rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.Gray;

                                                                                                                 // Set the page size
                                                                                                                 rasterizationOptions.PageSize = svgImage.Size;

                                                                                                                 // Antialiasing is applied to lines and curves and the edges of filled areas.
                                                                                                                 rasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.AntiAlias;

                                                                                                                 // Each character is drawn using its antialiased glyph bitmap without hinting.
                                                                                                                 rasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.AntiAlias;

                                                                                                                 // Reduce the image size 10 times, i.e. the output size will be 10% of the original size.
                                                                                                                 rasterizationOptions.ScaleX = 0.1f;
                                                                                                                 rasterizationOptions.ScaleY = 0.1f;

                                                                                                                 Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                 saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                 // Save to a PNG file
                                                                                                                 svgImage.Save(dir + "test.output.png", saveOptions);
                                                                                                             }

### <a id="Aspose_Imaging_ImageOptions_VectorRasterizationOptions_PageWidth"></a> PageWidth

Gets or sets the page width.
If the value is 0, the source image aspect ratio will be preserved.

```csharp
public float PageWidth { get; set; }

Property Value

float

Positioning

Gets or sets the positioning.

[JsonProperty]
public PositioningTypes Positioning { get; set; }

Property Value

PositioningTypes

Examples

The following example shows how to set a memory limit when loading a CMX image. The memory limit is the maximum allowed size (in megabytes) for all internal buffers.```csharp [C#]

                                                                                                                                                                            string dir = "c:\\aspose.imaging\\issues\\net\\3419\\";

                                                                                                                                                                            // Setting a memory limit of 10 megabytes for a target loaded image.
                                                                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "example.cmx", new Aspose.Imaging.LoadOptions() { BufferSizeHint = 10 }))
                                                                                                                                                                            {
                                                                                                                                                                                image.Save(dir + "output.png",
                                                                                                                                                                                    new Aspose.Imaging.ImageOptions.PngOptions()
                                                                                                                                                                                    {
                                                                                                                                                                                        VectorRasterizationOptions =
                                                                                                                                                                                                new Aspose.Imaging.ImageOptions.CmxRasterizationOptions
                                                                                                                                                                                                {
                                                                                                                                                                                                    TextRenderingHint = Aspose.Imaging.TextRenderingHint.SingleBitPerPixel,
                                                                                                                                                                                                    SmoothingMode = Aspose.Imaging.SmoothingMode.AntiAlias,
                                                                                                                                                                                                    Positioning = Aspose.Imaging.ImageOptions.PositioningTypes.DefinedByDocument
                                                                                                                                                                                                }
                                                                                                                                                                                    });
                                                                                                                                                                            }

The following example shows how to export all pages of CDR document to PDF.```csharp
[C#]

                                                                                      string dir = "c:\\aspose.imaging\\issues\\net\\3635\\testdata\\3570";
                                                                                      string inputCdrFileName = System.IO.Path.Combine(dir, "tiger.cdr");
                                                                                      string outputPdfFileName = System.IO.Path.Combine(dir, "tiger.cdr.pdf");

                                                                                      using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(inputCdrFileName))
                                                                                      {
                                                                                          Aspose.Imaging.ImageOptions.PdfOptions pdfOptions = new Aspose.Imaging.ImageOptions.PdfOptions();
                                                                                          Aspose.Imaging.ImageOptions.CdrRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.CdrRasterizationOptions
                                                                                          {
                                                                                              TextRenderingHint = Aspose.Imaging.TextRenderingHint.SingleBitPerPixel,
                                                                                              SmoothingMode = Aspose.Imaging.SmoothingMode.None,
                                                                                              Positioning = Aspose.Imaging.ImageOptions.PositioningTypes.DefinedByDocument
                                                                                          };

                                                                                          pdfOptions.VectorRasterizationOptions = rasterizationOptions;
                                                                                          image.Save(outputPdfFileName, pdfOptions);
                                                                                      }

ReplaceTextMapping

Gets or sets the text replace mapping.

[JsonProperty]
public Dictionary<string, string=""> ReplaceTextMapping { get; set; }

Property Value

Dictionary<string, string&gt;

SmoothingMode

Gets or sets the smoothing mode.

[JsonProperty]
public SmoothingMode SmoothingMode { get; set; }

Property Value

SmoothingMode

Examples

This example shows how to load an SVG image from a file and rasterize it to PNG using various options.```csharp [C#]

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

                                                                                                             // Using Aspose.Imaging.Image.Load is a unified way to load image.
                                                                                                             using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = (Aspose.Imaging.FileFormats.Svg.SvgImage)Aspose.Imaging.Image.Load(dir + "test.svg"))
                                                                                                             {
                                                                                                                 // In order to rasterize SVG we need to specify rasterization options.
                                                                                                                 Aspose.Imaging.ImageOptions.SvgRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.SvgRasterizationOptions();

                                                                                                                 // Set default color of a background for an image. Default value is white.
                                                                                                                 rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.Gray;

                                                                                                                 // Set the page size
                                                                                                                 rasterizationOptions.PageSize = svgImage.Size;

                                                                                                                 // Antialiasing is applied to lines and curves and the edges of filled areas.
                                                                                                                 rasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.AntiAlias;

                                                                                                                 // Each character is drawn using its antialiased glyph bitmap without hinting.
                                                                                                                 rasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.AntiAlias;

                                                                                                                 // Reduce the image size 10 times, i.e. the output size will be 10% of the original size.
                                                                                                                 rasterizationOptions.ScaleX = 0.1f;
                                                                                                                 rasterizationOptions.ScaleY = 0.1f;

                                                                                                                 Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                 saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                 // Save to a PNG file
                                                                                                                 svgImage.Save(dir + "test.output.png", saveOptions);
                                                                                                             }

### <a id="Aspose_Imaging_ImageOptions_VectorRasterizationOptions_TextRenderingHint"></a> TextRenderingHint

Gets or sets the text rendering hint.

```csharp
[JsonProperty]
public TextRenderingHint TextRenderingHint { get; set; }

Property Value

TextRenderingHint

Examples

This example shows how to load an SVG image from a file and rasterize it to PNG using various options.```csharp [C#]

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

                                                                                                             // Using Aspose.Imaging.Image.Load is a unified way to load image.
                                                                                                             using (Aspose.Imaging.FileFormats.Svg.SvgImage svgImage = (Aspose.Imaging.FileFormats.Svg.SvgImage)Aspose.Imaging.Image.Load(dir + "test.svg"))
                                                                                                             {
                                                                                                                 // In order to rasterize SVG we need to specify rasterization options.
                                                                                                                 Aspose.Imaging.ImageOptions.SvgRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.SvgRasterizationOptions();

                                                                                                                 // Set default color of a background for an image. Default value is white.
                                                                                                                 rasterizationOptions.BackgroundColor = Aspose.Imaging.Color.Gray;

                                                                                                                 // Set the page size
                                                                                                                 rasterizationOptions.PageSize = svgImage.Size;

                                                                                                                 // Antialiasing is applied to lines and curves and the edges of filled areas.
                                                                                                                 rasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.AntiAlias;

                                                                                                                 // Each character is drawn using its antialiased glyph bitmap without hinting.
                                                                                                                 rasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.AntiAlias;

                                                                                                                 // Reduce the image size 10 times, i.e. the output size will be 10% of the original size.
                                                                                                                 rasterizationOptions.ScaleX = 0.1f;
                                                                                                                 rasterizationOptions.ScaleY = 0.1f;

                                                                                                                 Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                 saveOptions.VectorRasterizationOptions = rasterizationOptions;

                                                                                                                 // Save to a PNG file
                                                                                                                 svgImage.Save(dir + "test.output.png", saveOptions);
                                                                                                             }

## Methods

### <a id="Aspose_Imaging_ImageOptions_VectorRasterizationOptions_CopyTo_Aspose_Imaging_ImageOptions_VectorRasterizationOptions_"></a> CopyTo\(VectorRasterizationOptions\)

Copies to.

```csharp
public virtual void CopyTo(VectorRasterizationOptions vectorRasterizationOptions)

Parameters

vectorRasterizationOptions VectorRasterizationOptions

The vector rasterization options. </string,>