Class GraphicsPath

Class GraphicsPath

De naam: Aspose.Imaging Verzameling: Aspose.Imaging.dll (25.4.0)

Het vertegenwoordigt een reeks verbonden lijnen en curves. deze klasse kan niet worden geërfd.

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

Inheritance

object ObjectWithBounds GraphicsPath

Geëerbiede leden

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

Deze voorbeelden maken gebruik van de GraphicsPath en Grafica-klasse om Figuren op een afbeeldingsoppervlak te maken en te manipuleren. Example creëert een nieuwe Afbeelding (van type Tiff), schoonmaakt de oppervloer en trekt paden met behulp van grafica Path.

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

Initialiseert een nieuwe instantie van de Aspose.Imaging.GraphicsPath-klasse.

[JsonConstructor]
public GraphicsPath()

Examples

Deze voorbeelden maken gebruik van de GraphicsPath en Grafica-klasse om Figuren op een afbeeldingsoppervlak te maken en te manipuleren. Example creëert een nieuwe Afbeelding (van type Tiff), schoonmaakt de oppervloer en trekt paden met behulp van grafica Path.

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

Initialiseert een nieuwe instantie van de Aspose.Imaging.GraphicsPath-klasse.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

De cijfers om te initialiseren.

GraphicsPath(Figure[], De FillMode)

Initialiseert een nieuwe instantie van de Aspose.Imaging.GraphicsPath-klasse.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

De cijfers om te initialiseren.

fillMode FillMode

De Fill Mode.

GraphicsPath(FillMode)

Initialiseert een nieuwe instantie van de Aspose.Imaging.GraphicsPath-klasse.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

De Fill Mode.

Properties

Bounds

Geeft of zet de grenzen van het object.

public override RectangleF Bounds { get; }

Eigendomswaarde

RectangleF

Figures

Geeft de route cijfers.

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

Eigendomswaarde

Figure []

FillMode

Geeft of stelt een Aspose.Imaging.FillMode-lijst die bepaalt hoe de interieurs van vormen in dit WR17.GraphicsPath worden gevuld.

public FillMode FillMode { get; set; }

Eigendomswaarde

FillMode

Methods

AddFigure(Figure)

Voeg een nieuwe figuur toe.

public void AddFigure(Figure figure)

Parameters

figure Figure

Het cijfer om toe te voegen.

Examples

Deze voorbeelden maken gebruik van de GraphicsPath en Grafica-klasse om Figuren op een afbeeldingsoppervlak te maken en te manipuleren. Example creëert een nieuwe Afbeelding (van type Tiff), schoonmaakt de oppervloer en trekt paden met behulp van grafica Path.

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

Voeg nieuwe cijfers toe.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

De cijfers om toe te voegen.

Examples

Dit voorbeeld creëert een nieuw beeld en trekt een verscheidenheid aan vormen met behulp van Figures en GraphicsPath op het beeldoppervlak.

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

Voeg de aangegeven Aspose.Imaging.GraphicsPath toe aan deze route.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

De Aspose.Imaging.GraphicsPath om toe te voegen.

AddPath(GraphicsPath, Bool)

Voeg de aangegeven Aspose.Imaging.GraphicsPath toe aan deze route.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

De Aspose.Imaging.GraphicsPath om toe te voegen.

connect bool

Een booleense waarde die bepaalt of de eerste cijfer in de toegevoegde route deel uitmaakt van de laatste cijfer in deze route. een waarde van waarheid bepaalt dat de eerste cijfer in de toegevoegde route deel uitmaakt van de laatste cijfer in deze route. een waarde van vals bepaalt dat de eerste cijfer in de toegevoegde route is gescheiden van de laatste cijfer in deze route.

DeepClone()

Het maakt een diepe kloon van deze grafische pad.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Een diepe kloon van de grafische pad.

Equals(Objecten)

Controleer of objecten gelijk zijn.

public override bool Equals(object obj)

Parameters

obj object

Het andere object.

Returns

bool

Het resultaat van de vergelijking van gelijkheid.

Flatten()

Converteert elke curve in deze route in een sequentie van verbonden lijnsegmenten.

public void Flatten()

Flatten(Matrix)

Gebruik de aangegeven transformatie en converteer vervolgens elke curve in dit Aspose.Imaging.GraphicsPath in een sequentie van aangesloten lijnsegmenten.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Een Aspose.Imaging.Matrix waarmee u deze WR17.GraphicsPath te transformeren vóór het flaten.

Flatten(Matrix en Float)

Converteert elke curve in dit Aspose.Imaging.GraphicsPath in een sequentie van verbonden lijnsegmenten.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Een Aspose.Imaging.Matrix waarmee u deze WR17.GraphicsPath te transformeren vóór het flaten.

flatness float

Specificeert de maximale toegestane fout tussen de curve en de vloeibare benadering. een waarde van 0.25 is de standaard. het verminderen van de benadering waarde zal het aantal lijnsegmenten in de benadering verhogen.

GetBounds(Matrix)

Krijg de grenzen van het object.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

De matrix die moet worden toegepast vóór de grenzen zal worden berekend.

Returns

RectangleF

De grenzen van het geschatte object.

GetBounds(Matrix en Pen)

Krijg de grenzen van het object.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

De matrix die moet worden toegepast vóór de grenzen zal worden berekend.

pen Pen

De pen om te gebruiken voor het object. Dit kan de grootte van de grenzen van het object beïnvloeden.

Returns

RectangleF

De grenzen van het geschatte object.

GetHashCode()

Krijg de hashcode van het huidige object.

public override int GetHashCode()

Returns

int

De hash code.

IsOutlineVisible(Vloot, Vloot en Pen)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen.

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

Parameters

x float

De x-koordinaat van het punt om te testen.

y float

De y-koordinaat van het punt om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(Hoofdstuk, Pen)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Een Aspose.Imaging.PointF waarin de locatie wordt aangegeven om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(vloat, vloat, pen, grafiek)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer het wordt afgebeeld met de specificeerde __ WL16_.Pen en met behulp van het specifieke WR17 .Grafics.

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

Parameters

x float

De x-koordinaat van het punt om te testen.

y float

De y-koordinaat van het punt om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath zoals getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(PointF, Pen en Graphics)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer het wordt afgebeeld met de specificeerde __ WL16_.Pen en met behulp van het specifieke WR17 .Grafics.

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

Parameters

pt PointF

Een Aspose.Imaging.PointF waarin de locatie wordt aangegeven om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath zoals getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(int, int, pen)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen.

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

Parameters

x int

De x-koordinaat van het punt om te testen.

y int

De y-koordinaat van het punt om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(Het punt, pen)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Een Aspose.Imaging.punt dat de locatie om te testen wijst.

pen Pen

De Aspose.Imaging.Pen om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath wanneer getransporteerd met de specificeerde WR17.Pen; anders, vals.

IsOutlineVisible(int, int, pen, grafiek)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer het wordt afgebeeld met de specificeerde __ WL16_.Pen en met behulp van het specifieke WR17 .Grafics.

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

Parameters

x int

De x-koordinaat van het punt om te testen.

y int

De y-koordinaat van het punt om te testen.

pen Pen

De Aspose.Imaging.Pen om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath zoals getransporteerd met de specifieke WR17.Pen; anders, vals.

IsOutlineVisible(Point, Pen en Graphics)

Het geeft aan of het aangegeven punt is opgenomen binnen (onder) de outline van dit Aspose.Imaging.GraphicsPath wanneer het wordt afgebeeld met de specificeerde __ WL16_.Pen en met behulp van het specifieke WR17 .Grafics.

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

Parameters

pt Point

Een Aspose.Imaging.punt dat de locatie om te testen wijst.

pen Pen

De Aspose.Imaging.Pen om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen in de outline van dit Aspose.Imaging.GraphicsPath zoals getransporteerd met de specifieke WR17.Pen; anders, vals.

IsVisible(De vloot, de vloot)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

De x-koordinaat van het punt om te testen.

y float

De y-koordinaat van het punt om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(puntf)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Een Aspose.Imaging.PointF die het punt vertegenwoordigt om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(int, int)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

De x-koordinaat van het punt om te testen.

y int

De y-koordinaat van het punt om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(Point)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Een Aspose.Imaging.punt dat het punt vertegenwoordigt om te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(Float, Float en Graphics)

Het geeft aan of het aangegeven punt binnen dit Aspose.Imaging.GraphicsPath is opgenomen in het zichtbare clipgebied van het specificeerde WR17.

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

Parameters

x float

De x-koordinaat van het punt om te testen.

y float

De y-koordinaat van het punt om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(PointF, Graphics)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Een Aspose.Imaging.PointF die het punt vertegenwoordigt om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode wordt waar als het aangegeven punt hierin is opgenomen; anders, vals.

IsVisible(int, int, grafiek)

Geef aan of het aangegeven punt is opgenomen binnen deze Aspose.Imaging.GraphicsPath, met behulp van de aangeduide __ WL16__ .Grafics.

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

Parameters

x int

De x-koordinaat van het punt om te testen.

y int

De y-koordinaat van het punt om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

IsVisible(punt, grafiek)

Het geeft aan of het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Een Aspose.Imaging.punt dat het punt vertegenwoordigt om te testen.

graphics Graphics

De Aspose.Imaging.Grafica voor welke zichtbaarheid te testen.

Returns

bool

Deze methode komt waar als het aangegeven punt is opgenomen binnen dit Aspose.Imaging.GraphicsPath; anders, vals.

RemoveFigure(Figure)

Verwijder een cijfer.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Het cijfer om te verwijderen.

RemoveFigures(Figure[])

Verwijder de cijfers.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

De cijfers te verwijderen.

Reset()

Vermijd de grafische pad en zet de Aspose.Imaging.FillMode op en voegt u de Wl17.

public void Reset()

Reverse()

Omgekeert de volgorde van cijfers, vormen en punten in elke vorm van deze Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Gebruik de aangegeven transformatie aan de vorm.

public override void Transform(Matrix transform)

Parameters

transform Matrix

De transformatie om toe te passen.

Warp(puntf[], RectangleF)

Gebruik een warp transform, gedefinieerd door een rectangle en een parallelogram, voor dit Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Een reeks van Aspose.Imaging.PointF-structuren die een parallelogram definiëren waartoe de rectangle gedefinieerd door srcRect’ wordt omgezet. de array kan drie of vier elementen bevatten.

srcRect RectangleF

Een Aspose.Imaging.RectangleF dat de rechthoek vertegenwoordigt die wordt omgezet in het parallelogram gedefinieerd door destPoints'.

Warp(puntf[], RectangleF, Matrix)

Gebruik een warp transform, gedefinieerd door een rectangle en een parallelogram, voor dit Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Een reeks van Aspose.Imaging.PointF-structuren die een parallelogram definiëren waartoe de rectangle gedefinieerd door srcRect’ wordt omgezet. de array kan drie of vier elementen bevatten.

srcRect RectangleF

Een Aspose.Imaging.RectangleF dat de rechthoek vertegenwoordigt die wordt omgezet in het parallelogram gedefinieerd door destPoints'.

matrix Matrix

Een Aspose.Imaging.Matrix dat een geometrische transformatie bepaalt om aan de route te passen.

Warp(puntf[], RectangleF, Matrix, WarpMode)

Gebruik een warp transform, gedefinieerd door een rectangle en een parallelogram, voor dit Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Een reeks van Aspose.Imaging.PointF-structuren die een parallelogram definieert waartoe de rectangle gedefinieerd door srcRect’ wordt omgezet. de array kan drie of vier elementen bevatten.

srcRect RectangleF

Een Aspose.Imaging.RectangleF dat de rechthoek vertegenwoordigt die wordt omgezet in het parallelogram gedefinieerd door destPoints'.

matrix Matrix

Een Aspose.Imaging.Matrix dat een geometrische transformatie bepaalt om aan de route te passen.

warpMode WarpMode

Een Aspose.Imaging.WarpMode-lijst waarin wordt aangegeven of deze warp-operatie het perspectief of bilijnmodus gebruikt.

Warp(puntf[], RectangleF, Matrix, WarpMode, vloot)

Gebruik een warp transform, gedefinieerd door een rectangle en een parallelogram, voor dit Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Een reeks van Aspose.Imaging.PointF-structuren die een parallelogram definiëren waartoe de rectangle gedefinieerd door srcRect’ wordt omgezet. de array kan drie of vier elementen bevatten.

srcRect RectangleF

Een Aspose.Imaging.RectangleF dat de rechthoek vertegenwoordigt die wordt omgezet in het parallelogram gedefinieerd door destPoints'.

matrix Matrix

Een Aspose.Imaging.Matrix dat een geometrische transformatie bepaalt om aan de route te passen.

warpMode WarpMode

Een Aspose.Imaging.WarpMode-lijst waarin wordt aangegeven of deze warp-operatie het perspectief of bilijnmodus gebruikt.

flatness float

Een waarde van 0 tot 1 dat bepaalt hoe vlak de resulterende pad is. voor meer informatie, zie de Aspose.Imaging.GraphicsPath.Flatten methoden.

Widen(Pen)

Voeg een extra outline toe aan de route.

public void Widen(Pen pen)

Parameters

pen Pen

Een Aspose.Imaging.Pen die de breedte bepaalt tussen de oorspronkelijke outline van de route en de nieuwe outlines deze methode creëert.

Widen(Hoofdstuk, Matrix)

Voeg een extra outline toe aan de Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Een Aspose.Imaging.Pen die de breedte bepaalt tussen de oorspronkelijke outline van de route en de nieuwe outlines deze methode creëert.

matrix Matrix

Een Aspose.Imaging.Matrix dat een transformatie bepaalt die moet worden toegepast op de route vóór de uitbreiding.

Widen(Pen, Matrix en Float)

Vervang dit Aspose.Imaging.GraphicsPath met curves die het gebied omvat dat wordt gevuld wanneer deze route wordt getrokken door de aangegeven pen.

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

Parameters

pen Pen

Een Aspose.Imaging.Pen die de breedte bepaalt tussen de oorspronkelijke outline van de route en de nieuwe outlines deze methode creëert.

matrix Matrix

Een Aspose.Imaging.Matrix dat een transformatie bepaalt die moet worden toegepast op de route vóór de uitbreiding.

flatness float

Een waarde die de vlakte voor curves bepaalt.

 Nederlands