Class GraphicsPath

Class GraphicsPath

Namn på plats: Aspose.Imaging Församling: Aspose.Imaging.dll (25.4.0)

Representerar en serie anslutna linjer och kurvor. Denna klass kan inte ärvas.

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

Inheritance

object ObjectWithBounds GraphicsPath

Arvsmedlemmar

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

Dessa exempel använder GraphicsPath och Graphics klass för att skapa och manipulera Figurer på en bild yta. Exempel skapar en ny bild (typ Tiff), rengör ytan och drar vägar med hjälp av GraphicsPath klass.

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

Initialiserar en ny instans av Aspose.Imaging.GraphicsPath klass.

[JsonConstructor]
public GraphicsPath()

Examples

Dessa exempel använder GraphicsPath och Graphics klass för att skapa och manipulera Figurer på en bild yta. Exempel skapar en ny bild (typ Tiff), rengör ytan och drar vägar med hjälp av GraphicsPath klass.

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

Initialiserar en ny instans av Aspose.Imaging.GraphicsPath klass.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [ ]

De siffror som ska initialiseras från.

GraphicsPath(Figure[ ], och FillMode)

Initialiserar en ny instans av Aspose.Imaging.GraphicsPath klass.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [ ]

De siffror som ska initialiseras från.

fillMode FillMode

Fyll på mode.

GraphicsPath(FillMode)

Initialiserar en ny instans av Aspose.Imaging.GraphicsPath klass.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Fyll på mode.

Properties

Bounds

Får eller sätter objektets gränser.

public override RectangleF Bounds { get; }

Fastighetsvärde

RectangleF

Figures

Få väg siffror.

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

Fastighetsvärde

Figure [ ]

FillMode

Få eller ställa in en Aspose.Imaging.FillMode förteckning som bestämmer hur interiörerna av former i denna Aspose.Imaging.GraphicsPath fylls.

public FillMode FillMode { get; set; }

Fastighetsvärde

FillMode

Methods

AddFigure(Figure)

Lägg till en ny figur.

public void AddFigure(Figure figure)

Parameters

figure Figure

Figuren att lägga till.

Examples

Dessa exempel använder GraphicsPath och Graphics klass för att skapa och manipulera Figurer på en bild yta. Exempel skapar en ny bild (typ Tiff), rengör ytan och drar vägar med hjälp av GraphicsPath klass.

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

Lägg till nya siffror.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [ ]

siffrorna att lägga till.

Examples

Detta exempel skapar en ny bild och drar en mängd olika former med hjälp av Figurer och GraphicsPath på bildytan.

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

Lägg till den angivna Aspose.Imaging.GraphicsPath till den här vägen.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Den Aspose.Imaging.GraphicsPath att lägga till.

AddPath(GrafikenPath, Bool)

Lägg till den angivna Aspose.Imaging.GraphicsPath till den här vägen.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Den Aspose.Imaging.GraphicsPath att lägga till.

connect bool

Ett booleanskt värde som anger om den första figuren i den tilläggsvägen är en del av den sista figuren i den här vägen. ett värde av sant anger att den första figuren i den tilläggsvägen är en del av den sista figuren i den här vägen. ett värde av falskt anger att den första figuren i den tilläggsvägen är adskilt från den sista figuren i den här vägen.

DeepClone()

Utför en djup klon av den här grafiska vägen.

public GraphicsPath DeepClone()

Returns

GraphicsPath

En djup klon av den grafiska vägen.

Equals(Objektet)

Kontrollera om objekt är lika.

public override bool Equals(object obj)

Parameters

obj object

Det andra objektet.

Returns

bool

jämställdhetens resultat.

Flatten()

Konverterar varje kurva i denna väg till en sekvens av anslutna linje segment.

public void Flatten()

Flatten(Matrix)

Tillämpa den angivna transformationen och konverterar sedan varje kurva i denna Aspose.Imaging.GraphicsPath till en sekvens av anslutna linje segment.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

En Aspose.Imaging.Matrix genom vilken för att omvandla denna Aspose.Imaging.GraphicsPath innan flätning.

Flatten(Matrix och Float)

Konverterar varje kurva i denna Aspose.Imaging.GraphicsPath till en sekvens av anslutna linje segment.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

En Aspose.Imaging.Matrix genom vilken för att omvandla denna Aspose.Imaging.GraphicsPath innan flätning.

flatness float

Anger det maximala tillåtna felet mellan kurvan och dess flätade närhet. Ett värde på 0.25 är standardvärdet. Att minska fasta värdet ökar antalet radsegment i närhet.

GetBounds(Matrix)

Hämta objektets gränser.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Matriken som ska tillämpas före gränserna kommer att beräknas.

Returns

RectangleF

gränserna för det uppskattade objektet.

GetBounds(Matrix och Pen)

Hämta objektets gränser.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Matriken som ska tillämpas före gränserna kommer att beräknas.

pen Pen

Penna att använda för objekt. Detta kan påverka objektets gränsvärde.

Returns

RectangleF

gränserna för det uppskattade objektet.

GetHashCode()

Få hashkod från det aktuella objektet.

public override int GetHashCode()

Returns

int

och hash koden.

IsOutlineVisible(flotta, flotta och penna)

Anger om den angivna punkten finns i (under) uttrycket av denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen.

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

Parameters

x float

X-koordinaten av punkten att testa.

y float

Den y-koordinaten av punkten att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten för denna Aspose.Imaging.GraphicsPath när dragit med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(Föremål, Pen)

Anger om den angivna punkten finns i (under) uttrycket av denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

En Aspose.Imaging.PointF som anger platsen att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten för denna Aspose.Imaging.GraphicsPath när dragit med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(Float, Float, Pen, Grafiken)

Anger om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen och använder den angivna Aspose.Imaging.Graphics.

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

Parameters

x float

X-koordinaten av punkten att testa.

y float

Den y-koordinaten av punkten att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath som dragits med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(PointF, Pen, Grafiken)

Anger om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen och använder den angivna Aspose.Imaging.Graphics.

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

Parameters

pt PointF

En Aspose.Imaging.PointF som anger platsen att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath som dragits med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(int, int, pen)

Anger om den angivna punkten finns i (under) uttrycket av denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen.

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

Parameters

x int

X-koordinaten av punkten att testa.

y int

Den y-koordinaten av punkten att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten för denna Aspose.Imaging.GraphicsPath när dragit med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(Avsnitt, Pen)

Anger om den angivna punkten finns i (under) uttrycket av denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

En Aspose.Imaging.Point som anger platsen att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten för denna Aspose.Imaging.GraphicsPath när dragit med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(int, int, pen, grafik)

Anger om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen och använder den angivna Aspose.Imaging.Graphics.

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

Parameters

x int

X-koordinaten av punkten att testa.

y int

Den y-koordinaten av punkten att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten i denna Aspose.Imaging.GraphicsPath som dragits med den angivna Aspose.Imaging.Pen; annars, falsk.

IsOutlineVisible(Poäng, Pen, Grafiken)

Anger om den angivna punkten finns i (under) utgångspunkten för denna Aspose.Imaging.GraphicsPath när den dragits med den angivna Aspose.Imaging.Pen och använder den angivna Aspose.Imaging.Graphics.

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

Parameters

pt Point

En Aspose.Imaging.Point som anger platsen att testa.

pen Pen

Den Aspose.Imaging.Pen att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i utgångspunkten i denna Aspose.Imaging.GraphicsPath som dragits med den angivna Aspose.Imaging.Pen; annars, falsk.

IsVisible(Flotta och flotta)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

X-koordinaten av punkten att testa.

y float

Den y-koordinaten av punkten att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(PointF)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

En Aspose.Imaging.PointF som representerar punkten att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(int, int)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

X-koordinaten av punkten att testa.

y int

Den y-koordinaten av punkten att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(Point)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

En Aspose.Imaging.Point som representerar punkten att testa.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(Float, Float och Grafiken)

Anger om den angivna punkten finns inom denna Aspose.Imaging.GraphicsPath i den synliga klippregionen av den angivna Aspose.Imaging.Graphics.

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

Parameters

x float

X-koordinaten av punkten att testa.

y float

Den y-koordinaten av punkten att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(PointF, Grafiken)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

En Aspose.Imaging.PointF som representerar punkten att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten ingår i den; annars falsk.

IsVisible(int, int, grafik)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath, med hjälp av den angivna Aspose.Imaging.Graphics.

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

Parameters

x int

X-koordinaten av punkten att testa.

y int

Den y-koordinaten av punkten att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

IsVisible(Poäng, Grafiken)

Anger om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

En Aspose.Imaging.Point som representerar punkten att testa.

graphics Graphics

Den Aspose.Imaging.Grafik för vilken att testa synlighet.

Returns

bool

Denna metod returnerar sant om den angivna punkten finns i denna Aspose.Imaging.GraphicsPath; annars, falsk.

RemoveFigure(Figure)

Ta bort en figur.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Figuren att ta bort.

RemoveFigures(Figure[])

Ta bort siffror.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [ ]

siffrorna att ta bort.

Reset()

Stäng grafikvägen och ställ in Aspose.Imaging.FillMode till Aspose.Imaging.FillMode.Alternate.

public void Reset()

Reverse()

Omvandla ordningen av figurer, former och punkter i varje form av denna Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Tillämpa den angivna omvandlingen till formen.

public override void Transform(Matrix transform)

Parameters

transform Matrix

omvandlingen att tillämpa.

Warp(PointF[ ], RectangleF)

Tillämpar en warp transform, definierad av en rektangel och en parallelogram, till denna Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

En rad av Aspose.Imaging.PointF strukturer som definierar en parallelogram till vilken rektangeln definierad av srcRect’ omvandlas.

srcRect RectangleF

En Aspose.Imaging.RectangleF som representerar rektangeln som omvandlas till den parallelogram som definieras av destPoints'.

Warp(PointF[ ], RectangleF, Matrix)

Tillämpar en warp transform, definierad av en rektangel och en parallelogram, till denna Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

En rad av Aspose.Imaging.PointF strukturer som definierar en parallelogram till vilken rektangeln definierad av srcRect’ omvandlas.

srcRect RectangleF

En Aspose.Imaging.RectangleF som representerar rektangeln som omvandlas till den parallelogram som definieras av destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix som anger en geometrisk transformation att tillämpa på vägen.

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

Tillämpar en warp transform, definierad av en rektangel och en parallelogram, till denna Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

En rad av Aspose.Imaging.PointF strukturer som definierar en parallelogram till vilken rektangeln definierad av srcRect’ omvandlas.

srcRect RectangleF

En Aspose.Imaging.RectangleF som representerar rektangeln som omvandlas till den parallelogram som definieras av destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix som anger en geometrisk transformation att tillämpa på vägen.

warpMode WarpMode

En Aspose.Imaging.WarpMode-förteckning som anger om denna warp-operation använder perspektiv eller biljettläge.

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

Tillämpar en warp transform, definierad av en rektangel och en parallelogram, till denna Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

En rad av Aspose.Imaging.PointF strukturer som definierar en parallelogram till vilken rektangeln definierad av srcRect’ omvandlas.

srcRect RectangleF

En Aspose.Imaging.RectangleF som representerar rektangeln som omvandlas till den parallelogram som definieras av destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix som anger en geometrisk transformation att tillämpa på vägen.

warpMode WarpMode

En Aspose.Imaging.WarpMode-förteckning som anger om denna warp-operation använder perspektiv eller biljettläge.

flatness float

Ett värde från 0 till 1 som anger hur platt den resulterande vägen är. för mer information, se Aspose.Imaging.GraphicsPath.Flatten metoder.

Widen(Pen)

Lägg till en extra utgångspunkt till vägen.

public void Widen(Pen pen)

Parameters

pen Pen

En Aspose.Imaging.Pen som anger bredden mellan den ursprungliga utgången av vägen och den nya utgången denna metod skapar.

Widen(Pen och Matrix)

Lägg till en extra upplaga till Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

En Aspose.Imaging.Pen som anger bredden mellan den ursprungliga utgången av vägen och den nya utgången denna metod skapar.

matrix Matrix

En Aspose.Imaging.Matrix som anger en transformation att tillämpa på vägen innan utvidgningen.

Widen(Pen, Matrix och Float)

Ersätter denna Aspose.Imaging.GraphicsPath med kurvor som täcker det område som fylls när denna väg dras av den angivna penna.

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

Parameters

pen Pen

En Aspose.Imaging.Pen som anger bredden mellan den ursprungliga utgången av vägen och den nya utgången denna metod skapar.

matrix Matrix

En Aspose.Imaging.Matrix som anger en transformation att tillämpa på vägen innan utvidgningen.

flatness float

Ett värde som anger plattheten för kurvor.

 Svenska