Class GraphicsPath

Class GraphicsPath

Le nom : Aspose.Imaging Assemblée: Aspose.Imaging.dll (25.4.0)

Il représente une série de lignes et de courbes connectées. cette classe ne peut pas être héritée.

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

Inheritance

object ObjectWithBounds GraphicsPath

I membri ereditari

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

Ces exemples utilisent la classe GraphicsPath et les graphiques pour créer et manipuler les Figures sur une surface d’image. Exemple crée une nouvelle image (de type Tiff), nettoie la surface et attire les chemins à l’aide de la classes GraphiquePate.

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

Initialisez une nouvelle instance de la classe Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Ces exemples utilisent la classe GraphicsPath et les graphiques pour créer et manipuler les Figures sur une surface d’image. Exemple crée une nouvelle image (de type Tiff), nettoie la surface et attire les chemins à l’aide de la classes GraphiquePate.

//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[])

Initialisez une nouvelle instance de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [ ]

Les chiffres à initialiser.

GraphicsPath(Figure[ ], Le FillMode)

Initialisez une nouvelle instance de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [ ]

Les chiffres à initialiser.

fillMode FillMode

La mode de remplissage.

GraphicsPath(FillMode)

Initialisez une nouvelle instance de la classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

La mode de remplissage.

Properties

Bounds

Obtenir ou fixer les limites de l’objet.

public override RectangleF Bounds { get; }

Valore di proprietà

RectangleF

Figures

Obtenez les chiffres de route.

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

Valore di proprietà

Figure [ ]

FillMode

Obtenez ou définissez une liste Aspose.Imaging.FillMode qui détermine la façon dont les intérieurs des formes dans ce WR17.GraphicsPath sont remplis.

public FillMode FillMode { get; set; }

Valore di proprietà

FillMode

Methods

AddFigure(Figure)

Ajouter une nouvelle figure.

public void AddFigure(Figure figure)

Parameters

figure Figure

Le chiffre à ajouter.

Examples

Ces exemples utilisent la classe GraphicsPath et les graphiques pour créer et manipuler les Figures sur une surface d’image. Exemple crée une nouvelle image (de type Tiff), nettoie la surface et attire les chemins à l’aide de la classes GraphiquePate.

//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[])

Ajouter de nouveaux chiffres.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [ ]

Les chiffres à ajouter.

Examples

Cet exemple crée une nouvelle image et attire une variété de formes en utilisant les Figures et GraphicsPath sur la surface de l’image

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

Ajouter le Aspose.Imaging.GraphicsPath spécifié à ce chemin.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Le Aspose.Imaging.GraphicsPath pour ajouter.

AddPath(GraphiquesPath, Bool)

Ajouter le Aspose.Imaging.GraphicsPath spécifié à ce chemin.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Le Aspose.Imaging.GraphicsPath pour ajouter.

connect bool

Une valeur boolienne indique si la première figure dans la voie ajoutée fait partie de la dernière figure dans cette voie. Une valeur de vérité indique que la première figure dans la voie ajoutée fait partie de la dernière figure dans cette voie. Une valeur de faux indique que la première figure dans la voie ajoutée est séparée de la dernière figure dans cette voie.

DeepClone()

Permet une clone profonde de ce parcours graphique.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Une clone profonde du parcours graphique.

Equals(Objets)

Verificare se gli oggetti sono uguali.

public override bool Equals(object obj)

Parameters

obj object

L’altro oggetto

Returns

bool

Il risultato della comparsa di uguaglianza.

Flatten()

Convertit chaque courbe dans ce chemin en une séquence de segments de ligne connectés.

public void Flatten()

Flatten(Matrix)

Applique la transformation spécifiée et convertit ensuite chaque courbe dans ce Aspose.Imaging.GraphicsPath en une séquence de segments de ligne connectés.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix par lequel vous pouvez transformer ce WR17.GraphicsPath avant de flatter.

Flatten(Matrix et Float)

Convertit chaque courbe dans ce Aspose.Imaging.GraphicsPath en une séquence de segments de ligne connectés.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix par lequel vous pouvez transformer ce WR17.GraphicsPath avant de flatter.

flatness float

spécifie l’erreur maximale autorisée entre la courbe et son approximation flatte. Une valeur de 0.25 est la défaut. Réduire la valeur de flatte augmentera le nombre de segments de ligne dans l’approximation.

GetBounds(Matrix)

Riceve i limiti dell’oggetto.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

La matrice da applicare prima dei limiti sarà calcolata.

Returns

RectangleF

I limiti dell’oggetto stimato.

GetBounds(Matrix et Pen)

Riceve i limiti dell’oggetto.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

La matrice da applicare prima dei limiti sarà calcolata.

pen Pen

La penna da usare per l’oggetto. Questo può influenzare la dimensione dei confini dell’oggetto.

Returns

RectangleF

I limiti dell’oggetto stimato.

GetHashCode()

Ottieni il codice hash dell’oggetto attuale.

public override int GetHashCode()

Returns

int

Il codice hash.

IsOutlineVisible(Feuille, Feuille et Pen)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le WR17.Pen.

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

pen Pen

Le Aspose.Imaging.Pen à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(Le point, le pen)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Un Aspose.Imaging.PointF qui spécifie l’emplacement à tester.

pen Pen

Le Aspose.Imaging.Pen à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(Float, Float, Pén, Graphiques)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le __ WL16_.Pen et en utilisant le W L17 .

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

pen Pen

Le Aspose.Imaging.Pen à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath tel qu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(PointF, Pén, Graphiques)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le __ WL16_.Pen et en utilisant le W L17 .

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

Parameters

pt PointF

Un Aspose.Imaging.PointF qui spécifie l’emplacement à tester.

pen Pen

Le Aspose.Imaging.Pen à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath tel qu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(int, int, pen)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le WR17.Pen.

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

pen Pen

Le Aspose.Imaging.Pen à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(Le point, le pen)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Un Aspose.Imaging.point qui spécifie l’emplacement à tester.

pen Pen

Le Aspose.Imaging.Pen à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été tiré avec le __ WL16_.Pen; autrement, faux.

IsOutlineVisible(int, int, pen, graphiques)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le __ WL16_.Pen et en utilisant le W L17 .

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

pen Pen

Le Aspose.Imaging.Pen à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath comme tiré avec le __ WL18__ .Pen spécificé; autrement, faux.

IsOutlineVisible(Point, Pen, Graphique)

Il indique si le point spécifié est contenu dans (en dessous) l’outline de ce Aspose.Imaging.GraphicsPath lorsqu’il a été dessiné avec le __ WL16_.Pen et en utilisant le W L17 .

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

Parameters

pt Point

Un Aspose.Imaging.point qui spécifie l’emplacement à tester.

pen Pen

Le Aspose.Imaging.Pen à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans l’outline de ce Aspose.Imaging.GraphicsPath comme tiré avec le __ WL18__ .Pen spécificé; autrement, faux.

IsVisible(Fleur, fleur)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(PointF)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Un Aspose.Imaging.PointF qui représente le point à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(int, int)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(Point)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Un Aspose.Imaging.point qui représente le point à tester.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(Float, Float et Graphiques)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath dans la région clipe visible du WR17.

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(PointF, graphiques)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF qui représente le point à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu à l’intérieur de celui-ci; sinon, faux.

IsVisible(int, int, graphiques)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath, à l’aide de la spécification WR17.

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

IsVisible(Point, graphiques)

Il indique si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.point qui représente le point à tester.

graphics Graphics

Le Aspose.Imaging.Graphics pour lequel tester la visibilité.

Returns

bool

Cette méthode revient valable si le point spécifié est contenu dans ce Aspose.Imaging.GraphicsPath; autrement, faux.

RemoveFigure(Figure)

Retirez une figure.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Le chiffre à supprimer.

RemoveFigures(Figure[])

Supprimer les chiffres.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [ ]

Les chiffres à supprimer.

Reset()

Commencez le chemin graphique et définissez le Aspose.Imaging.FillMode à W L17.

public void Reset()

Reverse()

Reverse l’ordre des figures, des formes et des points dans chaque forme de ce Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Applicare la trasformazione specificata alla forma.

public override void Transform(Matrix transform)

Parameters

transform Matrix

La trasformazione da applicare.

Warp(PointF[ ], Le RectangleF)

Applique une transformation de warp, définie par un rectangle et un parallélogramme, à ce Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Un arrêt de structures Aspose.Imaging.PointF qui définit un parallélogramme auquel le rectangle défini par srcRect’ est transformé. l’arrêt peut contenir trois ou quatre éléments. Si l’arrête contient trois éléments, le coin inférieur à droite du parallèle est impliqué par les trois premiers points.

srcRect RectangleF

Un Aspose.Imaging.RectangleF qui représente le rectange qui est transformé dans le parallélogramme défini par destPoints'.

Warp(PointF[ ], RectangleF, Matrix)

Applique une transformation de warp, définie par un rectangle et un parallélogramme, à ce Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Un arrêt de structures Aspose.Imaging.PointF qui définit un parallélogramme auquel le rectangle défini par srcRect’ est transformé. l’arrêt peut contenir trois ou quatre éléments. Si l’arrête contient trois éléments, le coin inférieur à droite du parallèle est impliqué par les trois premiers points.

srcRect RectangleF

Un Aspose.Imaging.RectangleF qui représente le rectange qui est transformé dans le parallélogramme défini par destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix qui spécifie une transformation géométrique à appliquer au chemin.

Warp(PointF[ ], RectangleF, Matrix et WarpMode)

Applique une transformation de warp, définie par un rectangle et un parallélogramme, à ce Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Une série de structures Aspose.Imaging.PointF qui définit un parallélogramme auquel le rectangle défini par srcRect’ est transformé.La série peut contenir trois ou quatre éléments.Si la série contient trois éléments, le coin inférieur à droite du parallèle est impliqué par les trois premiers points.

srcRect RectangleF

Un Aspose.Imaging.RectangleF qui représente le rectange qui est transformé dans le parallélogramme défini par destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix qui spécifie une transformation géométrique à appliquer au chemin.

warpMode WarpMode

Une liste Aspose.Imaging.WarpMode qui spécifie si cette opération de warp utilise la perspective ou le mode bilinaire.

Warp(PointF[ ], RectangleF, Matrix, WarpMode, Float)

Applique une transformation de warp, définie par un rectangle et un parallélogramme, à ce Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Un arrêt de structures Aspose.Imaging.PointF qui définit un parallélogramme auquel le rectangle défini par srcRect’ est transformé. l’arrêt peut contenir trois ou quatre éléments. Si l’arrête contient trois éléments, le coin inférieur à droite du parallèle est impliqué par les trois premiers points.

srcRect RectangleF

Un Aspose.Imaging.RectangleF qui représente le rectange qui est transformé dans le parallélogramme défini par destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix qui spécifie une transformation géométrique à appliquer au chemin.

warpMode WarpMode

Une liste Aspose.Imaging.WarpMode qui spécifie si cette opération de warp utilise la perspective ou le mode bilinaire.

flatness float

Une valeur de 0 à 1 qui spécifie combien la voie résultante est plat. Pour plus d’informations, voir le Aspose.Imaging.GraphicsPath.Flatten méthodes.

Widen(Pen)

Ajoutez un outil supplémentaire à la route.

public void Widen(Pen pen)

Parameters

pen Pen

Un Aspose.Imaging.Pen qui spécifie la largeur entre l’outline originale de la route et la nouvelle outline cette méthode crée.

Widen(Pén, Matrix)

Ajouter une outline supplémentaire au Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Un Aspose.Imaging.Pen qui spécifie la largeur entre l’outline originale de la route et la nouvelle outline cette méthode crée.

matrix Matrix

Un Aspose.Imaging.Matrix qui spécifie une transformation à appliquer sur le chemin avant d’étendre.

Widen(Pén, Matrix et Float)

Remplace ce Aspose.Imaging.GraphicsPath avec des courbes qui couvrent la zone qui est remplie lorsque ce chemin est tiré par la penne spécifiée.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen qui spécifie la largeur entre l’outline originale de la route et la nouvelle outline cette méthode crée.

matrix Matrix

Un Aspose.Imaging.Matrix qui spécifie une transformation à appliquer sur le chemin avant d’étendre.

flatness float

Une valeur qui spécifie la flancité pour les courbes.

 Français