Class GraphicsPath

Class GraphicsPath

Nom dels espais: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.4.0)

Representa una sèrie de línies i curves connectades. aquesta classe no es pot heretar.

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

Inheritance

object ObjectWithBounds GraphicsPath

Membres heretats

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

Examples

Aquests exemples fan ús de la classe GraphicsPath i Gràfics per crear i manipular Figures en una superfície d’imatge. Exemple crea una nova imatge (de tipus Tiff), neteja la superficial i treu els camins amb l’ajuda de Class Grapics.

//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

GraphicsPath()

Inicialitza una nova instància de la classe Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Aquests exemples fan ús de la classe GraphicsPath i Gràfics per crear i manipular Figures en una superfície d’imatge. Exemple crea una nova imatge (de tipus Tiff), neteja la superficial i treu els camins amb l’ajuda de Class Grapics.

//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();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

GraphicsPath(Figure[])

Inicialitza una nova instància de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

Les dades que s’han d’iniciar.

GraphicsPath(Figure[]El FillMode)

Inicialitza una nova instància de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

Les dades que s’han d’iniciar.

fillMode FillMode

La manera de llençar.

GraphicsPath(FillMode)

Inicialitza una nova instància de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

La manera de llençar.

Properties

Bounds

Obté o fixa els límits de l’objecte.

public override RectangleF Bounds { get; }

Valor de la propietat

RectangleF

Figures

Coneix els números del camí.

[JsonProperty]
public Figure[] Figures { get; }

Valor de la propietat

Figure []

FillMode

Obté o estableix una enumeració de Aspose.Imaging.FillMode que determina com s’omplen els interiors de les formes en aquest Wl17.GraphicsPath.

public FillMode FillMode { get; set; }

Valor de la propietat

FillMode

Methods

AddFigure(Figure)

Afegeix una nova figura.

public void AddFigure(Figure figure)

Parameters

figure Figure

La figura per afegir.

Examples

Aquests exemples fan ús de la classe GraphicsPath i Gràfics per crear i manipular Figures en una superfície d’imatge. Exemple crea una nova imatge (de tipus Tiff), neteja la superficial i treu els camins amb l’ajuda de Class Grapics.

//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();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

AddFigures(Figure[])

Afegeix noves figures.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

Els números per afegir.

Examples

Aquest exemple crea una nova imatge i treu una varietat de formes utilitzant Figures i GraphicsPath a la superfície de la imatge

//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();
                                                                                                                             }

AddPath(GraphicsPath)

Afegeix l’especificat Aspose.Imaging.GraphicsPath a aquest camí.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

El Aspose.Imaging.GraphicsPath per afegir.

AddPath(GRAFICSPATH, BOOL)

Afegeix l’especificat Aspose.Imaging.GraphicsPath a aquest camí.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

El Aspose.Imaging.GraphicsPath per afegir.

connect bool

Un valor booleà que especifica si la primera figura en el camí afegit forma part de l’última figura d’aquest camí.Un valor de veritat indica que el primer nombre de la ruta afegeix part del darrer nombre d’aquest trajecte.

DeepClone()

Performan una clona profunda d’aquest camí gràfic.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Una clona profunda del camí gràfic.

Equals(Objecte)

Veure si els objectes són iguals.

public override bool Equals(object obj)

Parameters

obj object

L’altre objecte

Returns

bool

El resultat de la comparació d’igualtat.

Flatten()

Converteix cada curva en aquest camí en una seqüència de segments de línia connectats.

public void Flatten()

Flatten(Matrix)

Aplica la transformació especificada i després converteix cada curva en aquest Aspose.Imaging.GraphicsPath en una seqüència de segments de línia connectats.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Una Aspose.Imaging.Matrix per la qual es pot transformar aquest __ WL16__ .GraphicsPath abans de flatenar.

Flatten(Matriu i Float)

Converteix cada curva en aquest Aspose.Imaging.GraphicsPath en una seqüència de segments de línia connectats.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Una Aspose.Imaging.Matrix per la qual es pot transformar aquest __ WL16__ .GraphicsPath abans de flatenar.

flatness float

Especifica l’error màxim permès entre la curva i la seva aproximació plana. Un valor de 0.25 és la default. Reduir el valor d’amplitud augmentarà el nombre de segments de línia en l’aproximación.

GetBounds(Matrix)

Es troben els límits de l’objecte.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

La matriu que s’ha d’aplicar abans dels límits es calcularà.

Returns

RectangleF

Els límits de l’objecte estimat.

GetBounds(Matriu i Pen)

Es troben els límits de l’objecte.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

La matriu que s’ha d’aplicar abans dels límits es calcularà.

pen Pen

La penya per utilitzar per a l’objecte. Això pot influir en la grandària dels límits de l’object.

Returns

RectangleF

Els límits de l’objecte estimat.

GetHashCode()

Obtenir el codi hash de l’objecte actual.

public override int GetHashCode()

Returns

int

El codi hash.

IsOutlineVisible(Plana, plana i penya)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen.

public bool IsOutlineVisible(float x, float y, Pen pen)

Parameters

x float

El x-coordinat del punt a provar.

y float

L’e-coordinat del punt a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(El punt, la penya)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Un Aspose.Imaging.PointF que especifica la ubicació a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(Float, Pèl, Gràfics)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat Wl17.Pen i utilitzant la especificació de _ WL16_ .Grafics.

public bool IsOutlineVisible(float x, float y, Pen pen, Graphics graphics)

Parameters

x float

El x-coordinat del punt a provar.

y float

L’e-coordinat del punt a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins (abans) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath tal com s’ha dissenyat amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(PointF, Pen, gràfics)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat Wl17.Pen i utilitzant la especificació de _ WL16_ .Grafics.

public bool IsOutlineVisible(PointF pt, Pen pen, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF que especifica la ubicació a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins (abans) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath tal com s’ha dissenyat amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(Int, Int i Pen)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen.

public bool IsOutlineVisible(int x, int y, Pen pen)

Parameters

x int

El x-coordinat del punt a provar.

y int

L’e-coordinat del punt a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(El punt, Pen)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Un Aspose.Imaging.Point que especifica la ubicació a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat WR17.Pen; en cas contrari, fals.

IsOutlineVisible(Int, int, pen, gràfics)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat Wl17.Pen i utilitzant la especificació de _ WL16_ .Grafics.

public bool IsOutlineVisible(int x, int y, Pen pen, Graphics graphics)

Parameters

x int

El x-coordinat del punt a provar.

y int

L’e-coordinat del punt a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath tal com s’ha dibuixat amb la especificada WR17.Pen; en cas contrari, falsa.

IsOutlineVisible(Punt, pen, gràfics)

Indica si el punt especificat es troba dins (darrere) de l’escriptura d’aquest Aspose.Imaging.GraphicsPath quan es tracti amb el especificat Wl17.Pen i utilitzant la especificació de _ WL16_ .Grafics.

public bool IsOutlineVisible(Point pt, Pen pen, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.Point que especifica la ubicació a provar.

pen Pen

El Aspose.Imaging.Pen per a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins de l’escriptura d’aquest Aspose.Imaging.GraphicsPath tal com s’ha dibuixat amb la especificada WR17.Pen; en cas contrari, falsa.

IsVisible(La flota, la flota)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

El x-coordinat del punt a provar.

y float

L’e-coordinat del punt a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(Punt F)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Un Aspose.Imaging.PointF que representa el punt a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(Int, Int)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

El x-coordinat del punt a provar.

y int

L’e-coordinat del punt a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(Point)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Un Aspose.Imaging.Point que representa el punt a provar.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(Float, float i gràfics)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath en la regió del clip visible de l’espectacle especificat.

public bool IsVisible(float x, float y, Graphics graphics)

Parameters

x float

El x-coordinat del punt a provar.

y float

L’e-coordinat del punt a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(PointF, gràfics)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF que representa el punt a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest; en cas contrari, fals.

IsVisible(Int, int i gràfics)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath, utilitzant l’espectacle especificat WR17.

public bool IsVisible(int x, int y, Graphics graphics)

Parameters

x int

El x-coordinat del punt a provar.

y int

L’e-coordinat del punt a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

IsVisible(Punt, gràfics)

Indica si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.Point que representa el punt a provar.

graphics Graphics

La Aspose.Imaging.Gràfica per a la qual es pot provar la visibilitat.

Returns

bool

Aquest mètode torna veritable si el punt especificat es troba dins d’aquest Aspose.Imaging.GraphicsPath; en cas contrari, fals.

RemoveFigure(Figure)

Elimina una figura.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

La figura per eliminar.

RemoveFigures(Figure[])

Elimina els números.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

Les xifres per eliminar.

Reset()

Emprega el recorregut gràfic i col·loca el Aspose.Imaging.FillMode a W L17.

public void Reset()

Reverse()

Reversa l’ordre de figures, formes i punts en cada forma d’aquest Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Aplica la transformació especificada a la forma.

public override void Transform(Matrix transform)

Parameters

transform Matrix

La transformació a aplicar.

Warp(Punt F[]El rectangle)

S’aplica una transformació d’arpa, definida per un rectangle i un paral·lelogram, a aquest Aspose.Imaging.GraphicsPath.

public void Warp(PointF[] destPoints, RectangleF srcRect)

Parameters

destPoints PointF []

Una sèrie de estructures Aspose.Imaging.PointF que defineix un paral·lelogram a la qual es transforma el rectangle definit per srcRect’. l’arrel pot contenir tres o quatre elements.

srcRect RectangleF

Un Aspose.Imaging.RectangleF que representa el recte que es transforma en el paral·lelogram definit per destPoints'.

Warp(Punt F[], RectangleF, Matriu)

S’aplica una transformació d’arpa, definida per un rectangle i un paral·lelogram, a aquest Aspose.Imaging.GraphicsPath.

public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix)

Parameters

destPoints PointF []

Una sèrie de estructures Aspose.Imaging.PointF que defineix un paral·lelogram a la qual es transforma el rectangle definit per srcRect’. l’arrel pot contenir tres o quatre elements.

srcRect RectangleF

Un Aspose.Imaging.RectangleF que representa el recte que es transforma en el paral·lelogram definit per destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix que especifica una transformació geomètrica per aplicar-se al camí.

Warp(Punt F[], RectangleF, Matriu, WarpMode)

S’aplica una transformació d’arpa, definida per un rectangle i un paral·lelogram, a aquest Aspose.Imaging.GraphicsPath.

public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix, WarpMode warpMode)

Parameters

destPoints PointF []

Una sèrie de estructures Aspose.Imaging.PointF que defineix un paral·lelogram a la qual es transforma el rectangle definit per srcRect’. l’arrel pot contenir tres o quatre elements. Si l’arrell conté tres elements, l ́angre inferior-dreu del parallelogram és implicat pels primers tres punts.

srcRect RectangleF

Un Aspose.Imaging.RectangleF que representa el recte que es transforma en el paral·lelogram definit per destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix que especifica una transformació geomètrica per aplicar-se al camí.

warpMode WarpMode

Una enumeració Aspose.Imaging.WarpMode que especifica si aquesta operació de warp utilitza la perspectiva o el mode bilateral.

Warp(Punt F[], RectangleF, Matriu, WarpMode, float)

S’aplica una transformació d’arpa, definida per un rectangle i un paral·lelogram, a aquest Aspose.Imaging.GraphicsPath.

public void Warp(PointF[] destPoints, RectangleF srcRect, Matrix matrix, WarpMode warpMode, float flatness)

Parameters

destPoints PointF []

Una sèrie de estructures Aspose.Imaging.PointF que defineix un paral·lelogram a la qual es transforma el rectangle definit per srcRect’. l’arrel pot contenir tres o quatre elements.

srcRect RectangleF

Un Aspose.Imaging.RectangleF que representa el recte que es transforma en el paral·lelogram definit per destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix que especifica una transformació geomètrica per aplicar-se al camí.

warpMode WarpMode

Una enumeració Aspose.Imaging.WarpMode que especifica si aquesta operació de warp utilitza la perspectiva o el mode bilateral.

flatness float

Un valor de 0 a 1 que especifica com és plana la ruta resultant. per a més informació, vegeu el Aspose.Imaging.GraphicsPath.Flatten mètodes.

Widen(Pen)

Afegeix una descripció addicional al camí.

public void Widen(Pen pen)

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica l’amplada entre la sortida original del camí i la nova sortida aquest mètode crea.

Widen(Màster, Matriu)

Afegeix una descripció addicional al Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica l’amplada entre la sortida original del camí i la nova sortida aquest mètode crea.

matrix Matrix

Un Aspose.Imaging.Matrix que especifica una transformació per aplicar al camí abans d’ampliació.

Widen(Pen, Matriu i Float)

Reemplaça aquest Aspose.Imaging.GraphicsPath amb curves que envolten l’àrea que s’omple quan aquest camí es treu per la penya especificada.

public void Widen(Pen pen, Matrix matrix, float flatness)

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica l’amplada entre la sortida original del camí i la nova sortida aquest mètode crea.

matrix Matrix

Un Aspose.Imaging.Matrix que especifica una transformació per aplicar al camí abans d’ampliació.

flatness float

Un valor que especifica la plana per a les curves.

 Català