Class GraphicsPath

Class GraphicsPath

Název místa: Aspose.Imaging Shromáždění: Aspose.Imaging.dll (25.4.0)

Představuje řadu připojených linií a křivek. Tato třída nelze zdědit.

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

Inheritance

object ObjectWithBounds GraphicsPath

Dědiční č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

Tyto příklady používají třídu GraphicsPath a Graphics, aby vytvořily a manipulovaly postavy na obrazové povrchu. Příklad vytváří nový obraz (typu Tiff), vyčistí povrch a vytváří trasy s pomocí třídy GraphicsPath.

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

Začíná nový příklad třídy Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Tyto příklady používají třídu GraphicsPath a Graphics, aby vytvořily a manipulovaly postavy na obrazové povrchu. Příklad vytváří nový obraz (typu Tiff), vyčistí povrch a vytváří trasy s pomocí třídy GraphicsPath.

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

Začíná nový příklad třídy Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []a[]

sla by se měly začít.

GraphicsPath(Figure[]a[], Stáhnout FillMode)

Začíná nový příklad třídy Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []a[]

sla by se měly začít.

fillMode FillMode

Vyplňte svůj režim.

GraphicsPath(FillMode)

Začíná nový příklad třídy Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Vyplňte svůj režim.

Properties

Bounds

Dostane nebo stanoví hranice objektu.

public override RectangleF Bounds { get; }

Hodnota nemovitosti

RectangleF

Figures

Získejte čísla na cest.

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

Hodnota nemovitosti

Figure []a[]

FillMode

Obdržíte nebo nastavíte seznam Aspose.Imaging.FillMode, který určuje, jak jsou interiéry tvarů v tomto Aspose.Imaging.GraphicsPath vyplněny.

public FillMode FillMode { get; set; }

Hodnota nemovitosti

FillMode

Methods

AddFigure(Figure)

Přidejte novou číslice.

public void AddFigure(Figure figure)

Parameters

figure Figure

slo k přidán.

Examples

Tyto příklady používají třídu GraphicsPath a Graphics, aby vytvořily a manipulovaly postavy na obrazové povrchu. Příklad vytváří nový obraz (typu Tiff), vyčistí povrch a vytváří trasy s pomocí třídy GraphicsPath.

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

Přidejte nové čísla.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []a[]

sla k přidán.

Examples

Tento příklad vytváří nový obrázek a vytváří různé tvary pomocí obrázků a grafikyPath 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)

Připojte specifikovaný Aspose.Imaging.GraphicsPath k této trase.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Přečtěte si o tématu Aspose.Imaging.GraphicsPath přidat.

AddPath(Původní název: Bool, Bool)

Připojte specifikovaný Aspose.Imaging.GraphicsPath k této trase.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Přečtěte si o tématu Aspose.Imaging.GraphicsPath přidat.

connect bool

Booleánová hodnota, která určuje, zda je první číslo v přidané dráze součástí posledního čísla v této dráze. hodnota pravdy určuje, že první číslo v přidané dráze je součástí posledního čísla v této dráze. hodnota falešnosti určuje, že první číslo v přidané dráze je odděleno od posledního čísla v této dráze.

DeepClone()

Vytváří hluboký klon této grafické stezky.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Je to hluboký klon grafické trasy.

Equals(Objekt)

Zkontrolujte, zda jsou objekty stejn.

public override bool Equals(object obj)

Parameters

obj object

Druhý objekt.

Returns

bool

Výsledkem je srovnání rovnosti.

Flatten()

Konvertuje každou křivku v této dráze do sekvence připojených linií segment.

public void Flatten()

Flatten(Matrix)

Použije specifikovanou transformaci a poté konvertuje každou křivku v tomto Aspose.Imaging.GraphicsPath do sekvence připojených segmentů linie.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix, kterým přeměnit tento Aspose.Imaging.GraphicsPath před pletením.

Flatten(Matrix a float)

Konvertuje každou křivku v tomto Aspose.Imaging.GraphicsPath do sekvence připojených segment.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Aspose.Imaging.Matrix, kterým přeměnit tento Aspose.Imaging.GraphicsPath před pletením.

flatness float

Určuje maximální povolenou chybu mezi kurvem a jeho přibližností. hodnotou 0,25 je výchozí. Snížení hodnoty přibližnosti zvýší počet řádkových segmentů v přibližnosti.

GetBounds(Matrix)

Obsahuje hranice objektu.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Matrix, který se použije před hranicemi, bude vypočítán.

Returns

RectangleF

Hranice odhadovaného objektu.

GetBounds(Matrix a Pen)

Obsahuje hranice objektu.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Matrix, který se použije před hranicemi, bude vypočítán.

pen Pen

Pen použít pro objekt. To může ovlivnit velikost hranic objektu.

Returns

RectangleF

Hranice odhadovaného objektu.

GetHashCode()

Získejte hash kód aktuálního objektu.

public override int GetHashCode()

Returns

int

Kód pro hash.

IsOutlineVisible(plavba, plavba, pen)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen.

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

Parameters

x float

X-koordinát bodu na zkoušku.

y float

Koordinaci bodu pro testován.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, když je vytištěn s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(Peníze, Pen)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Aspose.Imaging.PointF, který určuje umístění, které je třeba testovat.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, když je vytištěn s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(plavba, plavba, pen, grafika)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen a pomocí uvedeného Aspose.Imaging.Graphics.

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

Parameters

x float

X-koordinát bodu na zkoušku.

y float

Koordinaci bodu pro testován.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath, jak je vytištěno s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(PointF, Pen, Grafika)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen a pomocí uvedeného Aspose.Imaging.Graphics.

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

Parameters

pt PointF

Aspose.Imaging.PointF, který určuje umístění, které je třeba testovat.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath, jak je vytištěno s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(Peníze, Peníze)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen.

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

Parameters

x int

X-koordinát bodu na zkoušku.

y int

Koordinaci bodu pro testován.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, když je vytištěn s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(Článek, Pen)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Aspose.Imaging.Point, který určuje umístění, které je třeba testovat.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, když je vytištěn s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(int, int, pen, grafika)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen a pomocí uvedeného Aspose.Imaging.Graphics.

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

Parameters

x int

X-koordinát bodu na zkoušku.

y int

Koordinaci bodu pro testován.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, jak je vytištěno s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsOutlineVisible(Point, Pen, Grafika)

Ukazuje, zda je uvedený bod obsažen v rámci (pod) výstupu tohoto Aspose.Imaging.GraphicsPath při vytváření s uvedeným Aspose.Imaging.Pen a pomocí uvedeného Aspose.Imaging.Graphics.

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

Parameters

pt Point

Aspose.Imaging.Point, který určuje umístění, které je třeba testovat.

pen Pen

Původní název: Aspose.Imaging.Pen to test.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v rámci výstupu tohoto Aspose.Imaging.GraphicsPath, jak je vytištěno s uvedeným Aspose.Imaging.Pen; jinak, falešn.

IsVisible(Plzeň, Plzeň)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

X-koordinát bodu na zkoušku.

y float

Koordinaci bodu pro testován.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(PointF)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Aspose.Imaging.PointF, který představuje bod, který je třeba testovat.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(a int, int)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

X-koordinát bodu na zkoušku.

y int

Koordinaci bodu pro testován.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(Point)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Aspose.Imaging.Point, který představuje bod, který je třeba testovat.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(plavba, plavba, grafika)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath v viditelné oblasti klipu uvedeného Aspose.Imaging.Graphics.

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

Parameters

x float

X-koordinát bodu na zkoušku.

y float

Koordinaci bodu pro testován.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(PointF, grafika)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Aspose.Imaging.PointF, který představuje bod, který je třeba testovat.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v tomto; jinak falešn.

IsVisible(int, int, grafika)

Ukazuje, zda je specifikovaný bod obsažen v této Aspose.Imaging.GraphicsPath, pomocí specifikovaného Aspose.Imaging.Graphics.

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

Parameters

x int

X-koordinát bodu na zkoušku.

y int

Koordinaci bodu pro testován.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

IsVisible(bod, grafika)

Ukazuje, zda je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Aspose.Imaging.Point, který představuje bod, který je třeba testovat.

graphics Graphics

Aspose.Imaging.Graphics pro které testovat viditelnost.

Returns

bool

Tato metoda se vrací pravdivá, pokud je uvedený bod obsažen v této Aspose.Imaging.GraphicsPath; jinak, falešn.

RemoveFigure(Figure)

Zbavte se čísla.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

slo je třeba odstranit.

RemoveFigures(Figure[])

Odstraňuje čísla.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []a[]

sla je třeba odstranit.

Reset()

Vytvořte grafickou dráhu a nastavte Aspose.Imaging.FillMode na Aspose.Imaging.FillMode.Alternate.

public void Reset()

Reverse()

Obrátí pořadí čísel, tvarů a bodů v každé podobě tohoto Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Aplikuje specifikovanou transformaci na tvar.

public override void Transform(Matrix transform)

Parameters

transform Matrix

Přeměna k uplatněn.

Warp(PointF[]a[], RectangleF)

Aplikuje transformátor, definovaný rektanglem a paralelogramem, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []a[]

ada Aspose.Imaging.PointF struktury, které definují paralelogram, ke kterému je rektangle definované srcRect’ transformován. Řada může obsahovat buď tři nebo čtyři prvky. Pokud řada obsahuje tři prvky, dolní pravý úhel paralelogramu je implicován prvními třemi body.

srcRect RectangleF

Aspose.Imaging.RectangleF, který představuje pravý úhel, který je přeměněn na paralelogram definovaný destPoints'.

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

Aplikuje transformátor, definovaný rektanglem a paralelogramem, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []a[]

ada Aspose.Imaging.PointF struktury, které definují paralelogram, ke kterému je rektangle definované srcRect’ transformován. Řada může obsahovat buď tři nebo čtyři prvky. Pokud řada obsahuje tři prvky, dolní pravý úhel paralelogramu je implicován prvními třemi body.

srcRect RectangleF

Aspose.Imaging.RectangleF, který představuje pravý úhel, který je přeměněn na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, který specifikuje geometrickou transformaci, která se použije na cestu.

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

Aplikuje transformátor, definovaný rektanglem a paralelogramem, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []a[]

ada struktur Aspose.Imaging.PointF, která definuje paralelogram, ke kterému je rektangle definované srcRect’ transformováno. Řada může obsahovat buď tři nebo čtyři prvky. Pokud řada obsahuje tři prvky, dolní pravý úhel paralelogramu je implicován prvními třemi body.

srcRect RectangleF

Aspose.Imaging.RectangleF, který představuje pravý úhel, který je přeměněn na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, který specifikuje geometrickou transformaci, která se použije na cestu.

warpMode WarpMode

Aspose.Imaging.WarpMode seznam, který specifikuje, zda tato operace warp používá perspektivní nebo dvoustranný režim.

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

Aplikuje transformátor, definovaný rektanglem a paralelogramem, na tento Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []a[]

ada Aspose.Imaging.PointF struktury, které definují paralelogram, ke kterému je rektangle definované srcRect’ transformován. Řada může obsahovat buď tři nebo čtyři prvky. Pokud řada obsahuje tři prvky, dolní pravý úhel paralelogramu je implicován prvními třemi body.

srcRect RectangleF

Aspose.Imaging.RectangleF, který představuje pravý úhel, který je přeměněn na paralelogram definovaný destPoints'.

matrix Matrix

Aspose.Imaging.Matrix, který specifikuje geometrickou transformaci, která se použije na cestu.

warpMode WarpMode

Aspose.Imaging.WarpMode seznam, který specifikuje, zda tato operace warp používá perspektivní nebo dvoustranný režim.

flatness float

Hodnota od 0 do 1, která určuje, jak plochá je výsledná trasa. pro více informací viz Aspose.Imaging.GraphicsPath.Flatten metody.

Widen(Pen)

Přidejte k cestě další výstup.

public void Widen(Pen pen)

Parameters

pen Pen

Aspose.Imaging.Pen, který určuje šířku mezi původním výstupem trasy a novým výstupem vytváří tuto metodu.

Widen(Peníze, Matrix)

Přidejte další popis do aplikace Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Aspose.Imaging.Pen, který určuje šířku mezi původním výstupem trasy a novým výstupem vytváří tuto metodu.

matrix Matrix

Aspose.Imaging.Matrix, který specifikuje transformaci aplikovat na cestu před rozšířením.

Widen(Peníze, Matrix, Float)

Změní tento Aspose.Imaging.GraphicsPath kurvy, které zakrývají oblast, která je naplněna, když je tato trasa natáčená specifikovanou penou.

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

Parameters

pen Pen

Aspose.Imaging.Pen, který určuje šířku mezi původním výstupem trasy a novým výstupem vytváří tuto metodu.

matrix Matrix

Aspose.Imaging.Matrix, který specifikuje transformaci aplikovat na cestu před rozšířením.

flatness float

Hodnota, která určuje plochost pro kurvy.

 Čeština