Class GraphicsPath

Class GraphicsPath

Der Name: Aspose.Imaging Versammlung: Aspose.Imaging.dll (25.4.0)

Es repräsentiert eine Reihe von verbundenen Linien und Kurven. Diese Klasse kann nicht vererbt werden.

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

Inheritance

object ObjectWithBounds GraphicsPath

Vererbte Mitglieder

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

Diese Beispiele verwenden die GraphicsPath und die Graphics-Klasse, um Figuren auf einer Bildoberfläche zu erstellen und zu manipulieren. Das Beispiel schafft eine neue Image (Typ Tiff), reinigt die Oberfläche und zieht Wege mit der Hilfe der GraphicsPath-Klasse. Am Ende wird die von Graphics-Klasse ausgesprochenen DrawPath-Methode dazu aufgefordert, die Wege auf der Oberfläche zu machen.

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

Initialisiert eine neue Instanz der Aspose.Imaging.GraphicsPath Klasse.

[JsonConstructor]
public GraphicsPath()

Examples

Diese Beispiele verwenden die GraphicsPath und die Graphics-Klasse, um Figuren auf einer Bildoberfläche zu erstellen und zu manipulieren. Das Beispiel schafft eine neue Image (Typ Tiff), reinigt die Oberfläche und zieht Wege mit der Hilfe der GraphicsPath-Klasse. Am Ende wird die von Graphics-Klasse ausgesprochenen DrawPath-Methode dazu aufgefordert, die Wege auf der Oberfläche zu machen.

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

Initialisiert eine neue Instanz der Aspose.Imaging.GraphicsPath Klasse.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [][]

Die Zahlen zu initialisieren.

GraphicsPath(Figure[][], und FillMode)

Initialisiert eine neue Instanz der Aspose.Imaging.GraphicsPath Klasse.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [][]

Die Zahlen zu initialisieren.

fillMode FillMode

Die Füllmodus ausfüllen.

GraphicsPath(FillMode)

Initialisiert eine neue Instanz der Aspose.Imaging.GraphicsPath Klasse.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Die Füllmodus ausfüllen.

Properties

Bounds

Erhält oder legt die Grenzen des Objekts fest.

public override RectangleF Bounds { get; }

Eigentumswert

RectangleF

Figures

Sie erhalten die Path Figuren.

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

Eigentumswert

Figure [][]

FillMode

Er bekommt oder setzt eine Aspose.Imaging.FillMode-Liste, die bestimmt, wie die Innere der Formen in diesem Aspose.Imaging.GraphicsPath gefüllt sind.

public FillMode FillMode { get; set; }

Eigentumswert

FillMode

Methods

AddFigure(Figure)

Eine neue Figur hinzufügen.

public void AddFigure(Figure figure)

Parameters

figure Figure

Die Figur zu hinzufügen.

Examples

Diese Beispiele verwenden die GraphicsPath und die Graphics-Klasse, um Figuren auf einer Bildoberfläche zu erstellen und zu manipulieren. Das Beispiel schafft eine neue Image (Typ Tiff), reinigt die Oberfläche und zieht Wege mit der Hilfe der GraphicsPath-Klasse. Am Ende wird die von Graphics-Klasse ausgesprochenen DrawPath-Methode dazu aufgefordert, die Wege auf der Oberfläche zu machen.

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

Neue Zahlen hinzufügen.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [][]

Die Zahlen zu hinzufügen.

Examples

Dieses Beispiel schafft ein neues Bild und zieht eine Vielzahl von Formen mit Figuren und GraphicsPath auf der Bildoberfläche

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

Fügen Sie die angegebenen Aspose.Imaging.GraphicsPath auf diesen Weg hinzu.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Die Aspose.Imaging.GraphicsPath hinzufügen.

AddPath(GrafikenPath, Bool)

Fügen Sie die angegebenen Aspose.Imaging.GraphicsPath auf diesen Weg hinzu.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Die Aspose.Imaging.GraphicsPath hinzufügen.

connect bool

Ein Boolean-Wert, der angibt, ob die erste Figur im hinzugefügten Weg Teil der letzten Figur in diesem Weg ist. Ein Wert der Wahrheit angibt, dass die erste Figur im hinzugefügten Weg Teil der letzten Figur in diesem Weg ist. Ein Wert der falschen Angibt, dass die erste Figur im hinzugefügten Weg von der letzten Figur in diesem Weg getrennt ist.

DeepClone()

Erstellt eine tiefe Klone dieser grafischen Path.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Eine tiefe Klone des grafischen Paths.

Equals(Objekt)

berprüfen Sie, ob die Objekte gleich sind.

public override bool Equals(object obj)

Parameters

obj object

Das andere Objekt.

Returns

bool

Das Ergebnis der Gleichberechtigung.

Flatten()

Umwandelt jede Kurve in diesem Weg in eine Reihe von verbundenen Zeilen.

public void Flatten()

Flatten(Matrix)

Anwenden Sie die angegebenen Transformation und konvertieren Sie dann jede Kurve in diesem Aspose.Imaging.GraphicsPath in eine Reihe von verbundenen Zeilen.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Ein Aspose.Imaging.Matrix, mit dem Sie diese Aspose.Imaging.GraphicsPath vor dem Blättern verwandeln.

Flatten(Matrix und Float)

Umwandelt jede Kurve in diesem Aspose.Imaging.GraphicsPath in eine Reihe von verbundenen Zeilen.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Ein Aspose.Imaging.Matrix, mit dem Sie diese Aspose.Imaging.GraphicsPath vor dem Blättern verwandeln.

flatness float

Spezifiziert die maximale erlaubte Fehler zwischen der Kurve und seiner flüchteten Annäherung. Ein Wert von 0.25 ist die Standardwert. Die Reduzierung der Flachheit wird die Anzahl der Line Segmente in der Annäherung erhöhen.

GetBounds(Matrix)

Erhält die Grenzen des Objekts.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Die Matrix, die vor Grenzen angewendet wird, wird berechnet.

Returns

RectangleF

Die Grenzen des geschätzten Objekts.

GetBounds(Matrix und Pen)

Erhält die Grenzen des Objekts.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Die Matrix, die vor Grenzen angewendet wird, wird berechnet.

pen Pen

Die Pen zu verwenden für Objekt. Dies kann die Größe der Grenzen des Objekts beeinflussen.

Returns

RectangleF

Die Grenzen des geschätzten Objekts.

GetHashCode()

Erhalten Sie den Hashcode des aktuellen Objekts.

public override int GetHashCode()

Returns

int

Der Hash Code.

IsOutlineVisible(Fliegen, Fliegen und Pen)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn er mit dem angegebenen Aspose.Imaging.Pen ausgeführt wird.

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

Parameters

x float

Die X-Koordinate des Testpunkts.

y float

Die Y-Koordinate des Testpunkts.

pen Pen

Die Aspose.Imaging.Pen zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen geführt wird; sonst, falsch.

IsOutlineVisible(Stück, Pen)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn er mit dem angegebenen Aspose.Imaging.Pen ausgeführt wird.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Ein Aspose.Imaging.PointF, der die Stelle angibt, die zu testen ist.

pen Pen

Die Aspose.Imaging.Pen zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen geführt wird; sonst, falsch.

IsOutlineVisible(float, float, Pen, Grafiken)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen und mit dem angegebenen Aspose.Imaging.Graphics ausgeführt wird.

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

Parameters

x float

Die X-Koordinate des Testpunkts.

y float

Die Y-Koordinate des Testpunkts.

pen Pen

Die Aspose.Imaging.Pen zu testen.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath wie mit dem angegebenen Aspose.Imaging.Pen enthalten ist; sonst, falsch.

IsOutlineVisible(PointF, Pen und Grafiken)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen und mit dem angegebenen Aspose.Imaging.Graphics ausgeführt wird.

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

Parameters

pt PointF

Ein Aspose.Imaging.PointF, der die Stelle angibt, die zu testen ist.

pen Pen

Die Aspose.Imaging.Pen zu testen.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath wie mit dem angegebenen Aspose.Imaging.Pen enthalten ist; sonst, falsch.

IsOutlineVisible(Int, Int und Pen)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn er mit dem angegebenen Aspose.Imaging.Pen ausgeführt wird.

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

Parameters

x int

Die X-Koordinate des Testpunkts.

y int

Die Y-Koordinate des Testpunkts.

pen Pen

Die Aspose.Imaging.Pen zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen geführt wird; sonst, falsch.

IsOutlineVisible(Stück, Pen)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn er mit dem angegebenen Aspose.Imaging.Pen ausgeführt wird.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Ein Aspose.Imaging.Point, der die Stelle angibt, die zu testen ist.

pen Pen

Die Aspose.Imaging.Pen zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen geführt wird; sonst, falsch.

IsOutlineVisible(int, int, Pen, Grafiken)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen und mit dem angegebenen Aspose.Imaging.Graphics ausgeführt wird.

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

Parameters

x int

Die X-Koordinate des Testpunkts.

y int

Die Y-Koordinate des Testpunkts.

pen Pen

Die Aspose.Imaging.Pen zu testen.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath wie mit dem angegebenen Aspose.Imaging.Pen enthalten ist; sonst, falsch.

IsOutlineVisible(Punkt, Pen, Grafiken)

Angibt, ob der angegebenen Punkt innerhalb (unter) der Ausgabe dieses Aspose.Imaging.GraphicsPath enthalten ist, wenn mit dem angegebenen Aspose.Imaging.Pen und mit dem angegebenen Aspose.Imaging.Graphics ausgeführt wird.

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

Parameters

pt Point

Ein Aspose.Imaging.Point, der die Stelle angibt, die zu testen ist.

pen Pen

Die Aspose.Imaging.Pen zu testen.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt innerhalb der Ausgabe dieses Aspose.Imaging.GraphicsPath wie mit dem angegebenen Aspose.Imaging.Pen enthalten ist; sonst, falsch.

IsVisible(Flotte und Flotte)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(float x, float y)

Parameters

x float

Die X-Koordinate des Testpunkts.

y float

Die Y-Koordinate des Testpunkts.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(Punkte)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(PointF point)

Parameters

point PointF

Eine Aspose.Imaging.PointF, die den Punkt zum Test darstellt.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(und int, int)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(int x, int y)

Parameters

x int

Die X-Koordinate des Testpunkts.

y int

Die Y-Koordinate des Testpunkts.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(Point)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(Point point)

Parameters

point Point

Eine Aspose.Imaging.Point, die den Punkt zu testen darstellt.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(Flotte, Flotte und Grafiken)

Angibt, ob der angegebenen Punkt innerhalb dieser Aspose.Imaging.GraphicsPath in der sichtbaren Klipregion der angegebenen Aspose.Imaging.Graphics enthalten ist.

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

Parameters

x float

Die X-Koordinate des Testpunkts.

y float

Die Y-Koordinate des Testpunkts.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(PointF, Grafiken)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Eine Aspose.Imaging.PointF, die den Punkt zum Test darstellt.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn die angegebenen Punkt darin enthalten ist; sonst falsch.

IsVisible(Int, Int und Grafiken)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist, mit dem angegebenen Aspose.Imaging.Graphics.

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

Parameters

x int

Die X-Koordinate des Testpunkts.

y int

Die Y-Koordinate des Testpunkts.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

IsVisible(Punkt, Grafiken)

Angibt, ob der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Eine Aspose.Imaging.Point, die den Punkt zu testen darstellt.

graphics Graphics

Die Aspose.Imaging.Grafik, für die die Sichtbarkeit zu testen.

Returns

bool

Diese Methode kehrt wahr zurück, wenn der angegebenen Punkt in diesem Aspose.Imaging.GraphicsPath enthalten ist; sonst, falsch.

RemoveFigure(Figure)

Eine Figur entfernen.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Die Figur zu entfernen.

RemoveFigures(Figure[])

Die Zahlen entfernen.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [][]

Die Zahlen zu entfernen.

Reset()

Entfernen Sie den Grafikweg und setzen Sie die Aspose.Imaging.FillMode auf Aspose.Imaging.FillMode.Alternate.

public void Reset()

Reverse()

Umkehrt die Reihenfolge der Figuren, Formen und Punkte in jeder Form dieses Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Anwendung der angegebenen Transformation auf die Form.

public override void Transform(Matrix transform)

Parameters

transform Matrix

Die Transformation anzuwenden.

Warp(Punkte[][], und RectangleF)

Anwenden Sie eine Warp-Transformation, die durch einen Rechteck und einen Parallelogram definiert wird, auf diese Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Eine Reihe von Aspose.Imaging.PointF Strukturen, die ein Parallelogram definieren, zu dem die rechte Ecke definiert durch srcRect’ umgewandelt wird. Die Reihe kann entweder drei oder vier Elemente enthalten. Wenn die Reihe drei Elemente enthält, wird der niedrigere rechte Ecke des Parallelogramm durch die ersten drei Punkte impliziert.

srcRect RectangleF

Ein Aspose.Imaging.RectangleF, der den rechteckigen Bereich darstellt, der in das Parallelogram verwandelt wird, das durch destPoints" definiert wird'.

Warp(Punkte[][], RectangleF, Matrix)

Anwenden Sie eine Warp-Transformation, die durch einen Rechteck und einen Parallelogram definiert wird, auf diese Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Eine Reihe von Aspose.Imaging.PointF Strukturen, die ein Parallelogram definieren, zu dem die rechte Ecke definiert durch srcRect’ umgewandelt wird. Die Reihe kann entweder drei oder vier Elemente enthalten. Wenn die Reihe drei Elemente enthält, wird der niedrigere rechte Ecke des Parallelogramm durch die ersten drei Punkte impliziert.

srcRect RectangleF

Ein Aspose.Imaging.RectangleF, der den rechteckigen Bereich darstellt, der in das Parallelogram verwandelt wird, das durch destPoints" definiert wird'.

matrix Matrix

Ein Aspose.Imaging.Matrix, der eine geometrische Transformation angibt, die auf den Weg angewendet wird.

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

Anwenden Sie eine Warp-Transformation, die durch einen Rechteck und einen Parallelogram definiert wird, auf diese Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Eine Reihe von Aspose.Imaging.PointF Strukturen, die ein Parallelogram definiert, zu dem die rechte Ecke definiert durch srcRect’ umgewandelt wird. Die Reihe kann entweder drei oder vier Elemente enthalten.

srcRect RectangleF

Ein Aspose.Imaging.RectangleF, der den rechteckigen Bereich darstellt, der in das Parallelogram verwandelt wird, das durch destPoints" definiert wird'.

matrix Matrix

Ein Aspose.Imaging.Matrix, der eine geometrische Transformation angibt, die auf den Weg angewendet wird.

warpMode WarpMode

Eine Aspose.Imaging.WarpMode-Liste, die angibt, ob diese Warp-Aktion Perspektive oder bilinenar-Modus verwendet.

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

Anwenden Sie eine Warp-Transformation, die durch einen Rechteck und einen Parallelogram definiert wird, auf diese Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Eine Reihe von Aspose.Imaging.PointF Strukturen, die ein Parallelogram definieren, zu dem die rechte Ecke definiert durch srcRect’ umgewandelt wird. Die Reihe kann entweder drei oder vier Elemente enthalten. Wenn die Reihe drei Elemente enthält, wird der niedrigere rechte Ecke des Parallelogramm durch die ersten drei Punkte impliziert.

srcRect RectangleF

Ein Aspose.Imaging.RectangleF, der den rechteckigen Bereich darstellt, der in das Parallelogram verwandelt wird, das durch destPoints" definiert wird'.

matrix Matrix

Ein Aspose.Imaging.Matrix, der eine geometrische Transformation angibt, die auf den Weg angewendet wird.

warpMode WarpMode

Eine Aspose.Imaging.WarpMode-Liste, die angibt, ob diese Warp-Aktion Perspektive oder bilinenar-Modus verwendet.

flatness float

Ein Wert von 0 bis 1, der angibt, wie flach der resultierende Weg ist. Weitere Informationen finden Sie in Aspose.Imaging.GraphicsPath.Flatten Methoden.

Widen(Pen)

Hinzufügen Sie einen zusätzlichen Ausblick auf den Weg.

public void Widen(Pen pen)

Parameters

pen Pen

Ein Aspose.Imaging.Pen, der die Breite zwischen der ursprünglichen Ausgangsweise des Weges und der neuen Ausgangsweise bestimmt, erzeugt diese Methode.

Widen(Stück, Matrix)

Hinzufügen Sie eine zusätzliche Ausgabe zum Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Ein Aspose.Imaging.Pen, der die Breite zwischen der ursprünglichen Ausgangsweise des Weges und der neuen Ausgangsweise bestimmt, erzeugt diese Methode.

matrix Matrix

Ein Aspose.Imaging.Matrix, der eine Transformation angibt, die auf den Weg angewendet wird, bevor sie erweitert wird.

Widen(Pen, Matrix und Float)

ersetzt diese Aspose.Imaging.GraphicsPath mit Kurven, die das Gebiet, das gefüllt wird, wenn diese Path von der angegebenen Pen getrocknet wird.

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

Parameters

pen Pen

Ein Aspose.Imaging.Pen, der die Breite zwischen der ursprünglichen Ausgangsweise des Weges und der neuen Ausgangsweise bestimmt, erzeugt diese Methode.

matrix Matrix

Ein Aspose.Imaging.Matrix, der eine Transformation angibt, die auf den Weg angewendet wird, bevor sie erweitert wird.

flatness float

Ein Wert, der die Flachkeit für Kurven bestimmt.

 Deutsch