Class GraphicsPath

Class GraphicsPath

Navne til: Aspose.Imaging Sammensætning: Aspose.Imaging.dll (25.4.0)

Det repræsenterer en række forbundne linjer og kurver. Denne klasse kan ikke arves.

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

Inheritance

object ObjectWithBounds GraphicsPath

De arvede medlemmer

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

Disse eksempler gør brug af GraphicsPath og Grafikklasse til at oprette og manipulere Figurer på et billede overflade. Eksemplet skaber et nyt billede (type Tiff), renser overfladen og trækker veje ved hjælp af grafikklassen.

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

Initialiserer en ny instans af Aspose.Imaging.GraphicsPath klasse.

[JsonConstructor]
public GraphicsPath()

Examples

Disse eksempler gør brug af GraphicsPath og Grafikklasse til at oprette og manipulere Figurer på et billede overflade. Eksemplet skaber et nyt billede (type Tiff), renser overfladen og trækker veje ved hjælp af grafikklassen.

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

Initialiserer en ny instans af Aspose.Imaging.GraphicsPath klasse.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

Tallene skal initialiseres fra.

GraphicsPath(Figure[], af FillMode)

Initialiserer en ny instans af Aspose.Imaging.GraphicsPath klasse.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

Tallene skal initialiseres fra.

fillMode FillMode

De fylder mode.

GraphicsPath(FillMode)

Initialiserer en ny instans af Aspose.Imaging.GraphicsPath klasse.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

De fylder mode.

Properties

Bounds

Giver eller sætter objektets grænser.

public override RectangleF Bounds { get; }

Ejendomsværdi

RectangleF

Figures

Gør vejens tal.

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

Ejendomsværdi

Figure []

FillMode

Få eller indstille en Aspose.Imaging.FillMode liste, der bestemmer, hvordan indretningerne af former i denne Wl17.GraphicsPath er fyldt.

public FillMode FillMode { get; set; }

Ejendomsværdi

FillMode

Methods

AddFigure(Figure)

Tilføj en ny figur.

public void AddFigure(Figure figure)

Parameters

figure Figure

Figuren til at tilføje.

Examples

Disse eksempler gør brug af GraphicsPath og Grafikklasse til at oprette og manipulere Figurer på et billede overflade. Eksemplet skaber et nyt billede (type Tiff), renser overfladen og trækker veje ved hjælp af grafikklassen.

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

Tilføj nye tal.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

Tallene skal tilføjes.

Examples

Dette eksempel skaber et nyt billede og trækker en række former ved hjælp af Figurer og GraphicsPath på billedets overflade.

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

Tilføj den angivne Aspose.Imaging.GraphicsPath til denne vej.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Den Aspose.Imaging.GraphicsPath til at tilføje.

AddPath(Grafikforløbet, Bool)

Tilføj den angivne Aspose.Imaging.GraphicsPath til denne vej.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Den Aspose.Imaging.GraphicsPath til at tilføje.

connect bool

En booleansk værdi, der angiver, om den første figur i den tilføjet vej er en del af den sidste figur i denne vej. En værdi af sand angiver, at den første figur i den tilføjet vej er en del af den sidste figur i denne vej. En værdi af falsk angiver, at den første figur i den tilføjet vej er adskilt fra den sidste figur i denne vej.

DeepClone()

Det udfører en dyb klone af denne grafiske vej.

public GraphicsPath DeepClone()

Returns

GraphicsPath

En dyb klone af den grafiske vej.

Equals(Objekt)

Tjek, om objekterne er lige.

public override bool Equals(object obj)

Parameters

obj object

Det andet objekt.

Returns

bool

Sammenligning af ligestilling er resultatet.

Flatten()

Konverter hver kurve i denne vej til en sekvens af forbundet linje segmenter.

public void Flatten()

Flatten(Matrix)

Anvend den angivne transformation og konverterer derefter hver kurve i denne Aspose.Imaging.GraphicsPath til en sekvens af forbundet linje segmenter.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

En Aspose.Imaging.Matrix, hvorved man kan omdanne dette WR17.GraphicsPath, før man blæser.

Flatten(Matrix og Float)

Konverterer hver kurve i denne Aspose.Imaging.GraphicsPath til en sekvens af forbundet linje segmenter.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

En Aspose.Imaging.Matrix, hvorved man kan omdanne dette WR17.GraphicsPath, før man blæser.

flatness float

Angiver den maksimale tilladte fejl mellem kurven og dens flatte tilnærmelse. Et værdi af 0.25 er standardværdien. Reducering af flatsværdien vil øge antallet af linje segmenter i tilnærmelsen.

GetBounds(Matrix)

Gør objektets grænser.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Den matrix, der skal anvendes før grænser, vil blive beregnet.

Returns

RectangleF

Den anslåede objekts grænser.

GetBounds(Matrix og Pen)

Gør objektets grænser.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Den matrix, der skal anvendes før grænser, vil blive beregnet.

pen Pen

Den pen til brug for objekt. Dette kan påvirke objektets grænse størrelse.

Returns

RectangleF

Den anslåede objekts grænser.

GetHashCode()

Få hashkoden til det nuværende objekt.

public override int GetHashCode()

Returns

int

Det er hash koden.

IsOutlineVisible(Flåder, Flåder og Pen)

Indikerer, om det angivne punkt er indeholdt i (under) udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angiverne WR17.Pen.

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

Parameters

x float

Den x-koordinat af punktet til test.

y float

Den y-koordinat af punktet at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angive WR17.Pen; ellers falske.

IsOutlineVisible(Fællesskab, Pen)

Indikerer, om det angivne punkt er indeholdt i (under) udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angiverne WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

En Aspose.Imaging.PointF, der angiver placeringen til at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angive WR17.Pen; ellers falske.

IsOutlineVisible(flåd, flåd, pen, grafik)

Indikerer, om det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath, når det er trukket med den angiverede WR17.Pen og ved hjælp af den Angiveret _ www.grafika.dk .

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

Parameters

x float

Den x-koordinat af punktet til test.

y float

Den y-koordinat af punktet at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath som trækket med den angiverne WR17.Pen; ellers falske.

IsOutlineVisible(PointF, Pen og Grafik)

Indikerer, om det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath, når det er trukket med den angiverede WR17.Pen og ved hjælp af den Angiveret _ www.grafika.dk .

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

Parameters

pt PointF

En Aspose.Imaging.PointF, der angiver placeringen til at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath som trækket med den angiverne WR17.Pen; ellers falske.

IsOutlineVisible(Indt, Indt og Pen)

Indikerer, om det angivne punkt er indeholdt i (under) udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angiverne WR17.Pen.

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

Parameters

x int

Den x-koordinat af punktet til test.

y int

Den y-koordinat af punktet at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angive WR17.Pen; ellers falske.

IsOutlineVisible(Størrelse, Pen)

Indikerer, om det angivne punkt er indeholdt i (under) udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angiverne WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

En Aspose.Imaging.point, der angiver placeringen til at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af dette Aspose.Imaging.GraphicsPath, når det er trykket med den angive WR17.Pen; ellers falske.

IsOutlineVisible(Int, Int, Pen og Graphics)

Indikerer, om det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath, når det er trukket med den angiverede WR17.Pen og ved hjælp af den Angiveret _ www.grafika.dk .

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

Parameters

x int

Den x-koordinat af punktet til test.

y int

Den y-koordinat af punktet at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af denne Aspose.Imaging.GraphicsPath som trækket med den angiverne WR17.Pen; ellers falske.

IsOutlineVisible(Point, Pen og Graphics)

Indikerer, om det angivne punkt er indeholdt inden for (under) udtrykket af denne Aspose.Imaging.GraphicsPath, når det er trukket med den angiverede WR17.Pen og ved hjælp af den Angiveret _ www.grafika.dk .

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

Parameters

pt Point

En Aspose.Imaging.point, der angiver placeringen til at teste.

pen Pen

Den Aspose.Imaging.Pen til at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt inden for udtrykket af denne Aspose.Imaging.GraphicsPath som trækket med den angiverne WR17.Pen; ellers falske.

IsVisible(Flåder, Flåder)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

Den x-koordinat af punktet til test.

y float

Den y-koordinat af punktet at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(pointf)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

En Aspose.Imaging.PointF, der repræsenterer det punkt at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(Det er int)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

Den x-koordinat af punktet til test.

y int

Den y-koordinat af punktet at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(Point)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

En Aspose.Imaging.point, der repræsenterer det punkt at teste.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(Flåder, Flåder og Grafik)

Indikerer, om det angivne punkt er indeholdt inden for denne Aspose.Imaging.GraphicsPath i den synlige klippegion af den angiverne WR17.

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

Parameters

x float

Den x-koordinat af punktet til test.

y float

Den y-koordinat af punktet at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(PointF og grafik)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

En Aspose.Imaging.PointF, der repræsenterer det punkt at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i dette; ellers falsk.

IsVisible(Int, Int og Graphics)

Indikerer, om det angivne punkt er indeholdt inden for denne Aspose.Imaging.GraphicsPath, ved hjælp af den angive WR17.

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

Parameters

x int

Den x-koordinat af punktet til test.

y int

Den y-koordinat af punktet at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

IsVisible(Billeder, grafikkort)

Angiver, om det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

En Aspose.Imaging.point, der repræsenterer det punkt at teste.

graphics Graphics

Den Aspose.Imaging.Grafik for hvilken at teste synlighed.

Returns

bool

Denne metode returnerer sandt, hvis det angivne punkt er indeholdt i denne Aspose.Imaging.GraphicsPath; ellers falske.

RemoveFigure(Figure)

Fjern en figur.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Figuren skal fjernes.

RemoveFigures(Figure[])

Fjerner tallene.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

Tallene skal fjernes.

Reset()

Indtast grafikkortet og indsæt Aspose.Imaging.FillMode til W L17.

public void Reset()

Reverse()

Reverserer rækkefølgen af figurer, former og point i hver form af denne Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Anvend den angivne transformation til formen.

public override void Transform(Matrix transform)

Parameters

transform Matrix

Forvandlingen skal anvendes.

Warp(pointf[], af RectangleF)

Anvend en warp transform, defineret af en rektangle og en parallelogram, til dette Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

En række af Aspose.Imaging.PointF strukturer, der definerer en parallelogram, til hvilken rektanglen defineret af srcRect’ er omdannet. Array kan indeholde enten tre eller fire elementer. Hvis arrayet indeholder tre elemente, er den nedre højre hjørne af paralelogrammet impliseret af de første tre punkter.

srcRect RectangleF

En Aspose.Imaging.RectangleF, der repræsenterer rektanglen, som er omdannet til parallelogrammet defineret af destPoints'.

Warp(pointf[], RectangleF, Matrix)

Anvend en warp transform, defineret af en rektangle og en parallelogram, til dette Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

En række af Aspose.Imaging.PointF strukturer, der definerer en parallelogram, til hvilken rektanglen defineret af srcRect’ er omdannet. Array kan indeholde enten tre eller fire elementer. Hvis arrayet indeholder tre elemente, er den nedre højre hjørne af paralelogrammet impliseret af de første tre punkter.

srcRect RectangleF

En Aspose.Imaging.RectangleF, der repræsenterer rektanglen, som er omdannet til parallelogrammet defineret af destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix, der angiver en geometrisk transformation til anvendelse på vejen.

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

Anvend en warp transform, defineret af en rektangle og en parallelogram, til dette Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

En række af Aspose.Imaging.PointF strukturer, der definerer en parallelogram, til hvilken rektanglen defineret af srcRect’ er omdannet. Array kan indeholde enten tre eller fire elementer. Hvis arrayet indeholder tre elemente, er den nedre højre hjørne af paralelogrammet impliseret af de første tre punkter.

srcRect RectangleF

En Aspose.Imaging.RectangleF, der repræsenterer rektanglen, som er omdannet til parallelogrammet defineret af destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix, der angiver en geometrisk transformation til anvendelse på vejen.

warpMode WarpMode

En Aspose.Imaging.WarpMode liste, der angiver, om denne warp-operation bruger perspektiv eller bilinær mode.

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

Anvend en warp transform, defineret af en rektangle og en parallelogram, til dette Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

En række af Aspose.Imaging.PointF strukturer, der definerer en parallelogram, til hvilken rektanglen defineret af srcRect’ er omdannet. Array kan indeholde enten tre eller fire elementer. Hvis arrayet indeholder tre elemente, er den nedre højre hjørne af paralelogrammet impliseret af de første tre punkter.

srcRect RectangleF

En Aspose.Imaging.RectangleF, der repræsenterer rektanglen, som er omdannet til parallelogrammet defineret af destPoints'.

matrix Matrix

En Aspose.Imaging.Matrix, der angiver en geometrisk transformation til anvendelse på vejen.

warpMode WarpMode

En Aspose.Imaging.WarpMode liste, der angiver, om denne warp-operation bruger perspektiv eller bilinær mode.

flatness float

En værdi fra 0 til 1, der angiver, hvor flad den resulterende vej er. for mere information, se Aspose.Imaging.GraphicsPath.Flatten metoder.

Widen(Pen)

Tilføj en yderligere udledning til vejen.

public void Widen(Pen pen)

Parameters

pen Pen

En Aspose.Imaging.Pen, der angiver bredden mellem den oprindelige udlinje af vejen og den nye udline skaber denne metode.

Widen(Pæne, Matrix)

Tilføj en yderligere udgave til Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

En Aspose.Imaging.Pen, der angiver bredden mellem den oprindelige udlinje af vejen og den nye udline skaber denne metode.

matrix Matrix

En Aspose.Imaging.Matrix, der angiver en transformation til anvendelse på vejen før udvidelse.

Widen(Pæne, Matrix og Float)

Replacerer dette Aspose.Imaging.GraphicsPath med kurver, som omfatter det område, der er fyldt, når denne vej er trukket af den angivne pen.

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

Parameters

pen Pen

En Aspose.Imaging.Pen, der angiver bredden mellem den oprindelige udlinje af vejen og den nye udline skaber denne metode.

matrix Matrix

En Aspose.Imaging.Matrix, der angiver en transformation til anvendelse på vejen før udvidelse.

flatness float

En værdi, der angiver fladhed for kurver.

 Dansk