Class GraphicsPath

Class GraphicsPath

Numele spaţiului: Aspose.Imaging Asamblare: Aspose.Imaging.dll (25.4.0)

Reprezintă o serie de linii și curbe conectate. această clasă nu poate fi moștenită.

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

Inheritance

object ObjectWithBounds GraphicsPath

Membrii moștenitori

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

Aceste exemple folosesc clasa GraphicsPath și Clasa Grafica pentru a crea și manipula Figura pe o suprafață a imaginii. Exemplul creează o nouă imagine (de tipul Tiff), clarifică suprafata și atrage căi cu ajutorul clasei Grafics Path.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                     //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                     //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                     graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                     // save all changes.
                                                                                                                                                                                                                                                                                                                                                     image.Save();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

Constructors

GraphicsPath()

Inițializează o nouă instanță a clasei Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Aceste exemple folosesc clasa GraphicsPath și Clasa Grafica pentru a crea și manipula Figura pe o suprafață a imaginii. Exemplul creează o nouă imagine (de tipul Tiff), clarifică suprafata și atrage căi cu ajutorul clasei Grafics Path.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                     //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                     //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                     graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                     // save all changes.
                                                                                                                                                                                                                                                                                                                                                     image.Save();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

GraphicsPath(Figure[])

Inițializează o nouă instanță a clasei Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

cifrele care trebuie iniţializate.

GraphicsPath(Figure[], în FillMode)

Inițializează o nouă instanță a clasei Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

cifrele care trebuie iniţializate.

fillMode FillMode

Modul de umplere.

GraphicsPath(FillMode)

Inițializează o nouă instanță a clasei Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Modul de umplere.

Properties

Bounds

Obține sau stabilește limitele obiectului.

public override RectangleF Bounds { get; }

Valoarea proprietății

RectangleF

Figures

Obțineți cifrele de drum.

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

Valoarea proprietății

Figure []

FillMode

Obține sau stabilește o enumerare Aspose.Imaging.FillMode care determină modul în care sunt umplute interiorele formelor din acest Wl17.GraphicsPath.

public FillMode FillMode { get; set; }

Valoarea proprietății

FillMode

Methods

AddFigure(Figure)

Adăugați o nouă cifră.

public void AddFigure(Figure figure)

Parameters

figure Figure

Numărul care trebuie adăugat.

Examples

Aceste exemple folosesc clasa GraphicsPath și Clasa Grafica pentru a crea și manipula Figura pe o suprafață a imaginii. Exemplul creează o nouă imagine (de tipul Tiff), clarifică suprafata și atrage căi cu ajutorul clasei Grafics Path.

//Create an instance of FileStream
                                                                                                                                                                                                                                                                                                                                             using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.tiff", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                                                                                             {
                                                                                                                                                                                                                                                                                                                                                 //Create an instance of TiffOptions and set its various properties
                                                                                                                                                                                                                                                                                                                                                 Aspose.Imaging.ImageOptions.TiffOptions tiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                                                                                                                                                                                                                                                                 //Set the source for the instance of ImageOptions
                                                                                                                                                                                                                                                                                                                                                 tiffOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                                                                                                 //Create an instance of Image 
                                                                                                                                                                                                                                                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(tiffOptions, 500, 500))
                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                     //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                                                                                                     //Clear Graphics surface
                                                                                                                                                                                                                                                                                                                                                     graphics.Clear(Color.Wheat);

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of GraphicsPath class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.GraphicsPath graphicspath = new Aspose.Imaging.GraphicsPath();

                                                                                                                                                                                                                                                                                                                                                     //Create an instance of Figure class
                                                                                                                                                                                                                                                                                                                                                     Aspose.Imaging.Figure figure = new Aspose.Imaging.Figure();

                                                                                                                                                                                                                                                                                                                                                     //Add Shapes to Figure object
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.RectangleShape(new Aspose.Imaging.RectangleF(10f, 10f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.EllipseShape(new Aspose.Imaging.RectangleF(50f, 50f, 300f, 300f)));
                                                                                                                                                                                                                                                                                                                                                     figure.AddShape(new Aspose.Imaging.Shapes.PieShape(new Aspose.Imaging.RectangleF(new Aspose.Imaging.PointF(250f, 250f), new Aspose.Imaging.SizeF(200f, 200f)), 0f, 45f));

                                                                                                                                                                                                                                                                                                                                                     //Add Figure object to GraphicsPath
                                                                                                                                                                                                                                                                                                                                                     graphicspath.AddFigure(figure);

                                                                                                                                                                                                                                                                                                                                                     //Draw path with Pen object of color Black
                                                                                                                                                                                                                                                                                                                                                     graphics.DrawPath(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), graphicspath);

                                                                                                                                                                                                                                                                                                                                                     // save all changes.
                                                                                                                                                                                                                                                                                                                                                     image.Save();
                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                             }

AddFigures(Figure[])

Adăugați noi cifre.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

cifrele care trebuie adăugate.

Examples

Acest exemplu creează o nouă imagine și atrage o varietate de forme folosind Figura și GraphicsPath pe suprafața imaginii.

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

Adăugați Aspose.Imaging.GraphicsPath la această cale.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath pentru a adăuga.

AddPath(Cuvânt cheie, bool)

Adăugați Aspose.Imaging.GraphicsPath la această cale.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath pentru a adăuga.

connect bool

O valoare booleană care specifică dacă prima cifră a căii adăugate face parte din ultima cifră a căii adăugate. o valoare a adevărului specifică că prima cifră a căii adăugate face parte din ultima cifră a căii adăugate. o valoare a falsei specifică că prima cifră a căii adăugate este separată de ultima cifră a căii adăugate.

DeepClone()

Realizează o clonă profundă a acestei căi grafice.

public GraphicsPath DeepClone()

Returns

GraphicsPath

O clonă profundă a traseului grafic.

Equals(Obiectul)

Verificați dacă obiectele sunt egale.

public override bool Equals(object obj)

Parameters

obj object

celălalt obiect.

Returns

bool

Rezultatul comparării egalităţii.

Flatten()

Convertează fiecare curbă în această cale într-o secvență de segmente de linii conectate.

public void Flatten()

Flatten(Matrix)

Aplica transformarea specificată și apoi convertează fiecare curbă în acest Aspose.Imaging.GraphicsPath într-o secvență a segmentelor de linii conectate.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix prin care să transforme acest Wl17.GraphicsPath înainte de flatulență.

Flatten(Matrix și float)

Convertează fiecare curbă în acest Aspose.Imaging.GraphicsPath într-o secvență a segmentelor de linii conectate.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix prin care să transforme acest Wl17.GraphicsPath înainte de flatulență.

flatness float

Specificați eroarea maximă permisă între curbă și aproximația sa plăcută. O valoare de 0.25 este default. Reducerea valorii de flatitate va crește numărul de segmente de linie în aproximație.

GetBounds(Matrix)

Obțineți limitele obiectului.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Matrixul care trebuie aplicat înainte de limitele vor fi calculate.

Returns

RectangleF

Limitele obiectului estimat.

GetBounds(Matrică, Pen)

Obțineți limitele obiectului.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Matrixul care trebuie aplicat înainte de limitele vor fi calculate.

pen Pen

Penul de utilizare pentru obiect. Acest lucru poate influența dimensiunea limitelor obiectului.

Returns

RectangleF

Limitele obiectului estimat.

GetHashCode()

Obțineți codul hash al obiectului curent.

public override int GetHashCode()

Returns

int

Codul de hash.

IsOutlineVisible(în float, float, pen)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când este desenat cu indicarea specificată WR17.Pen.

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

Parameters

x float

Coordonatul x al punctului de testare.

y float

E-coordonatul punctului de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

Returns

bool

Această metodă se întoarce adevărată dacă punctul specificat este conținută în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath atunci când este retrasă cu specificația __ WL16_.Pen; în caz contrar, fals.

IsOutlineVisible(Poziție, Pen)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când este desenat cu indicarea specificată WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Un Aspose.Imaging.PointF care specifică locația de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

Returns

bool

Această metodă se întoarce adevărată dacă punctul specificat este conținută în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath atunci când este retrasă cu specificația __ WL16_.Pen; în caz contrar, fals.

IsOutlineVisible(float, float, pen, grafică)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când a fost desenat cu specificația __ WL18_.Pen și utilizând specificarea _wL19 .Grafics.

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

Parameters

x float

Coordonatul x al punctului de testare.

y float

E-coordonatul punctului de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată în cazul în care punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath, după cum a fost desenat cu specificul __ WL16__ .Pen; altfel, fals.

IsOutlineVisible(PointeF, Pen, Grafică)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când a fost desenat cu specificația __ WL18_.Pen și utilizând specificarea _wL19 .Grafics.

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

Parameters

pt PointF

Un Aspose.Imaging.PointF care specifică locația de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată în cazul în care punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath, după cum a fost desenat cu specificul __ WL16__ .Pen; altfel, fals.

IsOutlineVisible(int, int, pen)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când este desenat cu indicarea specificată WR17.Pen.

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

Parameters

x int

Coordonatul x al punctului de testare.

y int

E-coordonatul punctului de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

Returns

bool

Această metodă se întoarce adevărată dacă punctul specificat este conținută în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath atunci când este retrasă cu specificația __ WL16_.Pen; în caz contrar, fals.

IsOutlineVisible(Punctul Pen)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când este desenat cu indicarea specificată WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Un Aspose.Imaging.punct care specifică locația de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

Returns

bool

Această metodă se întoarce adevărată dacă punctul specificat este conținută în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath atunci când este retrasă cu specificația __ WL16_.Pen; în caz contrar, fals.

IsOutlineVisible(int, int, pen, grafică)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când a fost desenat cu specificația __ WL18_.Pen și utilizând specificarea _wL19 .Grafics.

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

Parameters

x int

Coordonatul x al punctului de testare.

y int

E-coordonatul punctului de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată în cazul în care punctul specificat este conținut în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath, după cum a fost desenat cu indicarea specificată WR17.Pen; în caz contrar, fals.

IsOutlineVisible(Poziție, Pen, Grafică)

Indică dacă punctul specificat este conținut în interiorul (în jos) al expoziției acestui Aspose.Imaging.GraphicsPath atunci când a fost desenat cu specificația __ WL18_.Pen și utilizând specificarea _wL19 .Grafics.

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

Parameters

pt Point

Un Aspose.Imaging.punct care specifică locația de testare.

pen Pen

Ceea ce trebuie testat este Aspose.Imaging.Pen.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată în cazul în care punctul specificat este conținut în secțiunea de referință a acestui Aspose.Imaging.GraphicsPath, după cum a fost desenat cu indicarea specificată WR17.Pen; în caz contrar, fals.

IsVisible(în float, float)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

Coordonatul x al punctului de testare.

y float

E-coordonatul punctului de testare.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(Punctul)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Un Aspose.Imaging.PointF care reprezintă punctul de testare.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(int, int)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

Coordonatul x al punctului de testare.

y int

E-coordonatul punctului de testare.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(Point)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Un Aspose.Imaging.punct care reprezintă punctul de testare.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(float, float, grafică)

Indică dacă punctul specificat este conținut în cadrul acestui Aspose.Imaging.GraphicsPath în regiunea vizibilă a clip-ului de pe specificul __ WL16__ .Grafics.

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

Parameters

x float

Coordonatul x al punctului de testare.

y float

E-coordonatul punctului de testare.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(Poziție, grafică)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF care reprezintă punctul de testare.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în interiorul acestuia; altfel, fals.

IsVisible(int, int, grafică)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath, folosind caracterul indicat WR17.

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

Parameters

x int

Coordonatul x al punctului de testare.

y int

E-coordonatul punctului de testare.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

IsVisible(Poziția, grafică)

Indică dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.punct care reprezintă punctul de testare.

graphics Graphics

Aspose.Imaging.Grafica pentru care să testați vizibilitatea.

Returns

bool

Această metodă revine adevărată dacă punctul specificat este conținut în acest Aspose.Imaging.GraphicsPath; altfel, fals.

RemoveFigure(Figure)

Îndepărtează o figură.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Numărul care trebuie îndepărtat.

RemoveFigures(Figure[])

Îndepărtează cifrele

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

cifrele care trebuie îndepărtate.

Reset()

Încărcați calea grafică și stabiliți Aspose.Imaging.FillMode la Wl17.

public void Reset()

Reverse()

Reversă ordinea cifrelor, formelor și punctelor în fiecare formă a acestui Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Se aplică transformarea specificată formei.

public override void Transform(Matrix transform)

Parameters

transform Matrix

transformarea care se aplică.

Warp(Punctul[], în rectangle)

Aplică o transformare warp, definită printr-un rectanglu și un paralelogram, la acest Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

O linie de structuri Aspose.Imaging.PointF care definește un paralelogram la care este transformat rectanglul definit de srcRect'.

srcRect RectangleF

Un Aspose.Imaging.RectangleF care reprezintă rectanglul care este transformat în paralelogram definit de destPoints'.

Warp(Punctul[], RectangleF și Matrix)

Aplică o transformare warp, definită printr-un rectanglu și un paralelogram, la acest Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

O linie de structuri Aspose.Imaging.PointF care definește un paralelogram la care este transformat rectanglul definit de srcRect'.

srcRect RectangleF

Un Aspose.Imaging.RectangleF care reprezintă rectanglul care este transformat în paralelogram definit de destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix care specifică o transformare geometrică pentru a se aplica drumului.

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

Aplică o transformare warp, definită printr-un rectanglu și un paralelogram, la acest Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

O linie de structuri Aspose.Imaging.PointF care definește un paralelogram la care este transformat rectanglul definit de srcRect'.

srcRect RectangleF

Un Aspose.Imaging.RectangleF care reprezintă rectanglul care este transformat în paralelogram definit de destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix care specifică o transformare geometrică pentru a se aplica drumului.

warpMode WarpMode

O enumerare Aspose.Imaging.WarpMode care specifică dacă această operațiune de warp utilizează modul perspectiv sau bilateral.

Warp(Punctul[], RectangleF, Matrix, WarpMode, float)

Aplică o transformare warp, definită printr-un rectanglu și un paralelogram, la acest Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

O linie de structuri Aspose.Imaging.PointF care definește un paralelogram la care este transformat rectanglul definit de srcRect'.

srcRect RectangleF

Un Aspose.Imaging.RectangleF care reprezintă rectanglul care este transformat în paralelogram definit de destPoints'.

matrix Matrix

Un Aspose.Imaging.Matrix care specifică o transformare geometrică pentru a se aplica drumului.

warpMode WarpMode

O enumerare Aspose.Imaging.WarpMode care specifică dacă această operațiune de warp utilizează modul perspectiv sau bilateral.

flatness float

O valoare de la 0 la 1 care specifică cât de flat este calea rezultată. pentru mai multe informații, consultați Aspose.Imaging.GraphicsPath.Flatten metode.

Widen(Pen)

Adăugați o evidență suplimentară a traseului.

public void Widen(Pen pen)

Parameters

pen Pen

Un Aspose.Imaging.Pen care specifică lățimea dintre linia de ieșire originală a traseului și noua linie este creată de această metodă.

Widen(Cuvânt cheie, Matrix)

Adăugați o listă suplimentară la Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Un Aspose.Imaging.Pen care specifică lățimea dintre linia de ieșire originală a traseului și noua linie este creată de această metodă.

matrix Matrix

Un Aspose.Imaging.Matrix care specifică o transformare care trebuie aplicată traseului înainte de extindere.

Widen(Pen, Matrix și float)

Înlocuiește acest Aspose.Imaging.GraphicsPath cu curbe care înconjoară zona care este umplută atunci când această cale este desenată de penă specificată.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen care specifică lățimea dintre linia de ieșire originală a traseului și noua linie este creată de această metodă.

matrix Matrix

Un Aspose.Imaging.Matrix care specifică o transformare care trebuie aplicată traseului înainte de extindere.

flatness float

O valoare care specifică flatitatea pentru curbe.

 Română