Class GraphicsPath

Class GraphicsPath

Pôvodný názov: Aspose.Imaging Zhromaždenie: Aspose.Imaging.dll (25.4.0)

Predstavuje sériu prepojených línií a kriviek. Táto trieda nemôže byť zdedená.

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

Inheritance

object ObjectWithBounds GraphicsPath

Z dedičných členov

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

Tieto príklady používajú triedu GraphicsPath a Grafika na vytvorenie a manipuláciu s Čísla na obrazovej povrchu. Príklad vytvára novú Obrázok (typu Tiff), vyčistí povrch a vytiahne cesty pomocou triedy grafika.

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

Iniciuje novú inštanciu triedy Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Tieto príklady používajú triedu GraphicsPath a Grafika na vytvorenie a manipuláciu s Čísla na obrazovej povrchu. Príklad vytvára novú Obrázok (typu Tiff), vyčistí povrch a vytiahne cesty pomocou triedy grafika.

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

Iniciuje novú inštanciu triedy Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

Čísla by sa mali začať od.

GraphicsPath(Figure[], a FillMode)

Iniciuje novú inštanciu triedy Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

Čísla by sa mali začať od.

fillMode FillMode

Vyplnenie v režime.

GraphicsPath(FillMode)

Iniciuje novú inštanciu triedy Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Vyplnenie v režime.

Properties

Bounds

Získať alebo nastaviť hranice objektu.

public override RectangleF Bounds { get; }

Hodnota nehnuteľnosti

RectangleF

Figures

Získajte čísla na ceste.

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

Hodnota nehnuteľnosti

Figure []

FillMode

Získajte alebo nastavíte zoznam Aspose.Imaging.FillMode, ktorý určuje, ako sú interiéry tvarov v tomto Wl17.GraphicsPath vyplnené.

public FillMode FillMode { get; set; }

Hodnota nehnuteľnosti

FillMode

Methods

AddFigure(Figure)

Pridajte novú číslicu

public void AddFigure(Figure figure)

Parameters

figure Figure

Číslo je potrebné pridať.

Examples

Tieto príklady používajú triedu GraphicsPath a Grafika na vytvorenie a manipuláciu s Čísla na obrazovej povrchu. Príklad vytvára novú Obrázok (typu Tiff), vyčistí povrch a vytiahne cesty pomocou triedy grafika.

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

Pridajte nové čísla.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

Čísla by sme mali pridať.

Examples

Tento príklad vytvára nový obrázok a zachytáva rôzne tvary pomocou Figury a GraphicsPath na povrchu obrazu

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

Pridajte špecifikovaný Aspose.Imaging.GraphicsPath na túto trasu.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath pridať.

AddPath(Pôvodný názov: Bool)

Pridajte špecifikovaný Aspose.Imaging.GraphicsPath na túto trasu.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath pridať.

connect bool

Booleánska hodnota, ktorá určuje, či je prvá číslica v pridanej ceste súčasťou poslednej číslice v tejto ceste. hodnota pravdy určuje, že prvá číslica v pridanej ceste je súčasťou poslednej číslice v tejto ceste. hodnota falošnej číslice určuje, že prvá číslica v pridanej ceste je oddelená od poslednej číslice v tejto ceste.

DeepClone()

Vykonáva hlboký klón tejto grafickej trasy.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Hlboký klón grafickej cesty.

Equals(objekty)

Skontrolujte, či sú objekty rovnaké.

public override bool Equals(object obj)

Parameters

obj object

Druhý objekt

Returns

bool

Výsledkom je porovnanie rovnosti.

Flatten()

Konvertuje každú krivku v tejto ceste do sekvencie prepojených líniových segmentov.

public void Flatten()

Flatten(Matrix)

Použije špecifikovanú transformáciu a potom konvertuje každú kurvu v tomto Aspose.Imaging.GraphicsPath do sekvencie pripojených líniových segmentov.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

A Aspose.Imaging.Matrix, ktorou premeniť tento Wl17.GraphicsPath pred pletením.

Flatten(Matrix a float)

Konvertuje každú krivku v tomto Aspose.Imaging.GraphicsPath do sekvencie pripojených líniových segmentov.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

A Aspose.Imaging.Matrix, ktorou premeniť tento Wl17.GraphicsPath pred pletením.

flatness float

Ukazuje maximálnu povolenú chybu medzi kurvou a jej rozptýlenou približnosťou. hodnota 0,25 je predvolená. Zníženie hodnoty plochosti zvýši počet líniových segmentov v približovaní.

GetBounds(Matrix)

Získava hranice objektu.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Matrix, ktorý sa má použiť pred hranicami, sa vypočíta.

Returns

RectangleF

Hranice odhadovaného objektu.

GetBounds(Matrix a Pen)

Získava hranice objektu.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Matrix, ktorý sa má použiť pred hranicami, sa vypočíta.

pen Pen

Pen na použitie pre objekt. To môže ovplyvniť veľkosť hraníc objektu.

Returns

RectangleF

Hranice odhadovaného objektu.

GetHashCode()

Získajte hash kód aktuálneho objektu.

public override int GetHashCode()

Returns

int

Kód na hash.

IsOutlineVisible(plávajúce, plávajúce, pen)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutý s špecifikovaným WR17.Pen.

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

Parameters

x float

X-koordinát bodu na testovanie.

y float

koordinát bodu na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedená položka obsiahnutá v podobe tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutá špecifikovaným WR17.Pen; inak je falošná.

IsOutlineVisible(Počítač, Pen)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutý s špecifikovaným WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

A Aspose.Imaging.PointF, ktorý určuje umiestnenie na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedená položka obsiahnutá v podobe tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutá špecifikovaným WR17.Pen; inak je falošná.

IsOutlineVisible(plavba, plavba, pen, grafika)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath pri vytlačení s špecifikovaným Wl17.Pen a použitím špecifického _www.grafika.

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

Parameters

x float

X-koordinát bodu na testovanie.

y float

koordinát bodu na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath ako vytiahnutý s špecifikovaným WR17.Pen; inak, falošné.

IsOutlineVisible(PointF, Pen, Grafika)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath pri vytlačení s špecifikovaným Wl17.Pen a použitím špecifického _www.grafika.

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

Parameters

pt PointF

A Aspose.Imaging.PointF, ktorý určuje umiestnenie na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath ako vytiahnutý s špecifikovaným WR17.Pen; inak, falošné.

IsOutlineVisible(int, int, pen)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutý s špecifikovaným WR17.Pen.

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

Parameters

x int

X-koordinát bodu na testovanie.

y int

koordinát bodu na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedená položka obsiahnutá v podobe tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutá špecifikovaným WR17.Pen; inak je falošná.

IsOutlineVisible(Názov: Pen)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutý s špecifikovaným WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Aspose.Imaging.bod, ktorý určuje umiestnenie na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedená položka obsiahnutá v podobe tohto Aspose.Imaging.GraphicsPath, keď je vytiahnutá špecifikovaným WR17.Pen; inak je falošná.

IsOutlineVisible(int, int, pen, grafika)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath pri vytlačení s špecifikovaným Wl17.Pen a použitím špecifického _www.grafika.

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

Parameters

x int

X-koordinát bodu na testovanie.

y int

koordinát bodu na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v podobe tohto Aspose.Imaging.GraphicsPath ako vytiahnutý s špecifikovaným __ WL16__ .Pen; inak, falošné.

IsOutlineVisible(Počítač, Pen, Grafika)

Ukazuje, či je uvedený bod obsiahnutý v rámci (pod) výtlačky tohto Aspose.Imaging.GraphicsPath pri vytlačení s špecifikovaným Wl17.Pen a použitím špecifického _www.grafika.

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

Parameters

pt Point

Aspose.Imaging.bod, ktorý určuje umiestnenie na testovanie.

pen Pen

Aspose.Imaging.Pen na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v podobe tohto Aspose.Imaging.GraphicsPath ako vytiahnutý s špecifikovaným __ WL16__ .Pen; inak, falošné.

IsVisible(Pláž, Pláž)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

X-koordinát bodu na testovanie.

y float

koordinát bodu na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(Počítač)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

A Aspose.Imaging.PointF, ktorý predstavuje bod na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(a int, int)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

X-koordinát bodu na testovanie.

y int

koordinát bodu na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(Point)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

A Aspose.Imaging.bod, ktorý predstavuje bod na testovanie.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(plavba, plavba, grafika)

Ukazuje, či je špecifikovaná položka obsiahnutá v tomto Aspose.Imaging.GraphicsPath v viditeľnom klipovom regióne špecifického WR17.

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

Parameters

x float

X-koordinát bodu na testovanie.

y float

koordinát bodu na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(Počítač, grafika)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

A Aspose.Imaging.PointF, ktorý predstavuje bod na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v ňom; inak, falošné.

IsVisible(int, int, grafika)

Ukazuje, či je uvedený bod obsiahnutý v rámci tejto Aspose.Imaging.GraphicsPath, pomocou špecifikovanej WR17.

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

Parameters

x int

X-koordinát bodu na testovanie.

y int

koordinát bodu na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

IsVisible(Názov, grafika)

Ukazuje, či je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

A Aspose.Imaging.bod, ktorý predstavuje bod na testovanie.

graphics Graphics

Aspose.Imaging.Grafika pre ktorú testovať viditeľnosť.

Returns

bool

Táto metóda sa vráti pravdivá, ak je uvedený bod obsiahnutý v tomto Aspose.Imaging.GraphicsPath; inak, falošné.

RemoveFigure(Figure)

Odstrániť číslo.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Číslo na odstránenie.

RemoveFigures(Figure[])

Odstrániť čísla.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

Čísla na odstránenie.

Reset()

Vložte grafickú trasu a nastavíte Aspose.Imaging.FillMode na W L17.

public void Reset()

Reverse()

Obráti poriadok čísel, tvarov a bodov v každej podobe tohto Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Aplikuje špecifikovanú transformáciu na tvar.

public override void Transform(Matrix transform)

Parameters

transform Matrix

Premeny na uplatnenie.

Warp(Počítač[], RectangleF)

Aplikuje transformáciu warp, definovanú rektanglom a paralelogramom, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Súprava Aspose.Imaging.PointF štruktúry, ktoré definujú paralelogram, ku ktorému je rektangol definovaný srcRect’ transformovaný. súprava môže obsahovať buď tri alebo štyri prvky.

srcRect RectangleF

Aspose.Imaging.RectangleF, ktorý predstavuje rektanglu, ktorá sa transformuje na paralelogram definovaný destPoints'.

Warp(Počítač[], RectangleF , Matrix)

Aplikuje transformáciu warp, definovanú rektanglom a paralelogramom, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Súprava Aspose.Imaging.PointF štruktúry, ktoré definujú paralelogram, ku ktorému je rektangol definovaný srcRect’ transformovaný. súprava môže obsahovať buď tri alebo štyri prvky.

srcRect RectangleF

Aspose.Imaging.RectangleF, ktorý predstavuje rektanglu, ktorá sa transformuje na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, ktorý špecifikuje geometrickú transformáciu, ktorá sa vzťahuje na cestu.

Warp(Počítač[], RectangleF, Matrix, WarpMode)

Aplikuje transformáciu warp, definovanú rektanglom a paralelogramom, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Súprava Aspose.Imaging.PointF štruktúry, ktoré definujú paralelogram, ku ktorému je rektangol definovaný srcRect’ transformovaný. súprava môže obsahovať buď tri alebo štyri prvky.

srcRect RectangleF

Aspose.Imaging.RectangleF, ktorý predstavuje rektanglu, ktorá sa transformuje na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, ktorý špecifikuje geometrickú transformáciu, ktorá sa vzťahuje na cestu.

warpMode WarpMode

Aspose.Imaging.WarpMode zoznam, ktorý uvádza, či táto operácia warp používa perspektívny alebo dvojstranný režim.

Warp(Počítač[], RectangleF, Matrix, WarpMode, Float)

Aplikuje transformáciu warp, definovanú rektanglom a paralelogramom, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Súprava Aspose.Imaging.PointF štruktúry, ktoré definujú paralelogram, ku ktorému je rektangol definovaný srcRect’ transformovaný. súprava môže obsahovať buď tri alebo štyri prvky.

srcRect RectangleF

Aspose.Imaging.RectangleF, ktorý predstavuje rektanglu, ktorá sa transformuje na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, ktorý špecifikuje geometrickú transformáciu, ktorá sa vzťahuje na cestu.

warpMode WarpMode

Aspose.Imaging.WarpMode zoznam, ktorý uvádza, či táto operácia warp používa perspektívny alebo dvojstranný režim.

flatness float

Hodnota od 0 do 1, ktorá určuje, ako plochá je výsledná trasa. pre viac informácií pozri Aspose.Imaging.GraphicsPath.Flatten metódy.

Widen(Pen)

Pridajte ďalší výstup k trati.

public void Widen(Pen pen)

Parameters

pen Pen

A Aspose.Imaging.Pen, ktorý špecifikuje šírku medzi pôvodnou východiskou cesty a novou východom vytvorí táto metóda.

Widen(Pôda, Matrix)

Pridajte ďalší výstup do Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

A Aspose.Imaging.Pen, ktorý špecifikuje šírku medzi pôvodnou východiskou cesty a novou východom vytvorí táto metóda.

matrix Matrix

Aspose.Imaging.Matrix, ktorý špecifikuje transformáciu, ktorá sa má aplikovať na cestu pred rozšírením.

Widen(Pen, Matrix a Float)

Zmeniť tento Aspose.Imaging.GraphicsPath s krúžkami, ktoré zahŕňajú oblasť, ktorá je naplnená, keď je táto cesta vytiahnutá špecifikovanou penou.

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

Parameters

pen Pen

A Aspose.Imaging.Pen, ktorý špecifikuje šírku medzi pôvodnou východiskou cesty a novou východom vytvorí táto metóda.

matrix Matrix

Aspose.Imaging.Matrix, ktorý špecifikuje transformáciu, ktorá sa má aplikovať na cestu pred rozšírením.

flatness float

Hodnotu, ktorá určuje plochosť pre krivky.

 Slovenčina