Class Figure

Class Figure

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

The figure. A container for shapes.

[JsonObject(MemberSerialization.OptIn)]
public class Figure : ObjectWithBounds

Inheritance

objectObjectWithBoundsFigure

Inherited Members

ObjectWithBounds.GetBounds(Matrix), ObjectWithBounds.GetBounds(Matrix, Pen), ObjectWithBounds.Transform(Matrix), ObjectWithBounds.Equals(object), ObjectWithBounds.GetHashCode(), ObjectWithBounds.Equals(ObjectWithBounds), ObjectWithBounds.Bounds, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Examples

This examples make use of GraphicsPath and Graphics class to create and manipulate Figures on an Image surface. Example creates a new Image (of type Tiff), clears the surface and draws paths with the help of GraphicsPath class. At the end DrawPath method exposed by Graphics class is called to render the paths on surface.```csharp [C#]

                                                                                                                                                                                                                                                                                                                                         //Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                         using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                                                                                             //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                             Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                             //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                             tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                             //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                 //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                 graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                 //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                 //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                 graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                 //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                 graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                 // save all changes.
                                                                                                                                                                                                                                                                                                                                                 image.Save();
                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                         }

## Constructors

### <a id="Aspose_Imaging_Figure__ctor"></a> Figure\(\)

Initializes a new Aspose.Imaging.Figure instance.
A constructor required for a JSON deserialization.

```csharp
public Figure()

Properties

Bounds

Gets or sets the object’s bounds.

public override RectangleF Bounds { get; }

Property Value

RectangleF

IsClosed

Gets or sets a value indicating whether this figure is closed. A closed figure will make a difference only in case where the first and the last figure’s shapes are continuous shapes. In such case the first point of the first shape will be connected by a straight line from the last point of the last shape.

public bool IsClosed { get; set; }

Property Value

bool

Segments

Gets the whole figure segments.

public ShapeSegment[] Segments { get; }

Property Value

ShapeSegment[]

Shapes

Gets the shapes.

[JsonProperty]
public Shape[] Shapes { get; }

Property Value

Shape[]

Methods

AddShape(Shape)

Adds a shape to the figure.

public void AddShape(Shape shape)

Parameters

shape Shape

The shape to add.

Examples

This examples make use of GraphicsPath and Graphics class to create and manipulate Figures on an Image surface. Example creates a new Image (of type Tiff), clears the surface and draws paths with the help of GraphicsPath class. At the end DrawPath method exposed by Graphics class is called to render the paths on surface.```csharp [C#]

                                                                                                                                                                                                                                                                                                                                         //Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                         using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                         {
                                                                                                                                                                                                                                                                                                                                             //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                             Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                             //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                             tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                             //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                 //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                 graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                 //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                 figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                 //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                 graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                 //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                 graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                 // save all changes.
                                                                                                                                                                                                                                                                                                                                                 image.Save();
                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                         }

This example creates a new Image and draws a variety of shapes using Figures and GraphicsPath on the Image surface```csharp
[C#]

                                                                                                                             //Creates an instance of BmpOptions and set its various properties            
                                                                                                                             Aspose.Imaging.ImageOptions.BmpOptions bmpOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
                                                                                                                             bmpOptions.BitsPerPixel = 24;

                                                                                                                             //Create an instance of FileCreateSource and assign it as Source for the instance of BmpOptions
                                                                                                                             //Second Boolean parameter determines if the file to be created IsTemporal or not
                                                                                                                             bmpOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(@"c:\temp\output.bmp", false);

                                                                                                                             //Create an instance of Image 
                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(bmpOptions, 500, 500))
                                                                                                                             {
                                                                                                                                 //Create and initialize an instance of Graphics class
                                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                 //Clear Graphics surface
                                                                                                                                 graphics.Clear(Color.Wheat);

                                                                                                                                 //Create an instance of GraphicsPath class
                                                                                                                                 Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                 //Create an instance of Figure class
                                                                                                                                 Aspose.Imaging.Figure figure1 = new Aspose.Imaging.Figure();

                                                                                                                                 //Add Shape to Figure object
                                                                                                                                 figure1.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new RectangleF(50, 50, 300, 300)));
                                                                                                                                 figure1.AddShape(new Aspose.Imaging.Shapes.PieShape(new Rectangle(new Point(110, 110), new Size(200, 200)), 0, 90));

                                                                                                                                 //Create an instance of Figure class
                                                                                                                                 Aspose.Imaging.Figure figure2 = new Aspose.Imaging.Figure();

                                                                                                                                 //Add Shape to Figure object
                                                                                                                                 figure2.AddShape(new Aspose.Imaging.Shapes.ArcShape(new Aspose.Imaging.RectangleF(10, 10, 300, 300), 0, 45));
                                                                                                                                 figure2.AddShape(new Aspose.Imaging.Shapes.PolygonShape(new[] { new Aspose.Imaging.PointF(150, 10), new Aspose.Imaging.PointF(150, 200), new Aspose.Imaging.PointF(250, 300), new Aspose.Imaging.PointF(350, 400) }, true));
                                                                                                                                 figure2.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(200, 200))));

                                                                                                                                 //Add Figure object to GraphicsPath
                                                                                                                                 graphicspath.AddFigures(new[] { figure1, figure2 });

                                                                                                                                 //Draw path with Pen object of color Black
                                                                                                                                 graphics.DrawPath(new Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                 // save all changes.
                                                                                                                                 image.Save();
                                                                                                                             }

AddShapes(Shape[])

Adds a range of shapes to the figure.

public void AddShapes(Shape[] shapes)

Parameters

shapes Shape[]

The shapes to add.

Equals(object)

Determines whether the specified object is equal to the current object.

public override bool Equals(object obj)

Parameters

obj object

The compared object.

Returns

bool

The result of equals

GetBounds(Matrix)

Gets the object’s bounds.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

The matrix to apply before bounds will be calculated.

Returns

RectangleF

The estimated object’s bounds.

GetBounds(Matrix, Pen)

Gets the object’s bounds.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

The matrix to apply before bounds will be calculated.

pen Pen

The pen to use for object. This can influence the object’s bounds size.

Returns

RectangleF

The estimated object’s bounds.

GetHashCode()

Serves as the default hash function.

public override int GetHashCode()

Returns

int

A hash code for the current object.

RemoveShape(Shape)

Removes a shape from the figure.

public void RemoveShape(Shape shape)

Parameters

shape Shape

The shape to remove.

RemoveShapes(Shape[])

Removes a range of shapes from the figure.

public void RemoveShapes(Shape[] shapes)

Parameters

shapes Shape[]

The shapes range to remove.

Reverse()

Reverses this figure shapes order and shapes point order.

public void Reverse()

Transform(Matrix)

Applies the specified transformation to the shape.

public override void Transform(Matrix transform)

Parameters

transform Matrix

The transformation to apply.