Class GraphicsPath

Class GraphicsPath

ja nimityö: Aspose.Imaging Kokoelma: Aspose.Imaging.dll (25.4.0)

Se edustaa sarjaa liitettyjä linjoja ja kurvia. Tämä luokka ei voi perittyä.

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

Inheritance

object ObjectWithBounds GraphicsPath

Perintöjäsenet

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

Näitä esimerkkejä käytetään GraphicsPath- ja grafiikkaklassia luomaan ja manipuloimaan Kuvan pinnalla olevia hahmoja. Esimerkki luo uuden kuvan (tiff-tyypin), puhdistaa pinnan ja vetää reittejä Grafics Path -luokan avulla.

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

Aloitetaan uusi esimerkki Aspose.Imaging.GraphicsPath luokasta.

[JsonConstructor]
public GraphicsPath()

Examples

Näitä esimerkkejä käytetään GraphicsPath- ja grafiikkaklassia luomaan ja manipuloimaan Kuvan pinnalla olevia hahmoja. Esimerkki luo uuden kuvan (tiff-tyypin), puhdistaa pinnan ja vetää reittejä Grafics Path -luokan avulla.

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

Aloitetaan uusi esimerkki Aspose.Imaging.GraphicsPath luokasta.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure []

Laskelmat on aloitettava.

GraphicsPath(Figure[], ja FillMode)

Aloitetaan uusi esimerkki Aspose.Imaging.GraphicsPath luokasta.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure []

Laskelmat on aloitettava.

fillMode FillMode

Täytyy täyttää mode.

GraphicsPath(FillMode)

Aloitetaan uusi esimerkki Aspose.Imaging.GraphicsPath luokasta.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

Täytyy täyttää mode.

Properties

Bounds

Kohtaa tai asettaa kohteen rajat.

public override RectangleF Bounds { get; }

Omistuksen arvo

RectangleF

Figures

Saa tietä numeroita.

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

Omistuksen arvo

Figure []

FillMode

Saa tai asettaa Aspose.Imaging.FillMode-luettelon, joka määrittää, miten tämän Wl17.GraphicsPathin muotojen sisätilat täyttyvät.

public FillMode FillMode { get; set; }

Omistuksen arvo

FillMode

Methods

AddFigure(Figure)

Lisää uusi luku.

public void AddFigure(Figure figure)

Parameters

figure Figure

Määrä lisätään.

Examples

Näitä esimerkkejä käytetään GraphicsPath- ja grafiikkaklassia luomaan ja manipuloimaan Kuvan pinnalla olevia hahmoja. Esimerkki luo uuden kuvan (tiff-tyypin), puhdistaa pinnan ja vetää reittejä Grafics Path -luokan avulla.

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

Lisää uusia lukuja.

public void AddFigures(Figure[] figures)

Parameters

figures Figure []

Lukuja on lisättävä.

Examples

Tämä esimerkki luo uuden Kuvan ja vetää erilaisia muotoja käyttämällä Kuvaa ja GraphicsPath kuvan pinnalla

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

Liitä määritetty Aspose.Imaging.GraphicsPath tähän reittiin.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath lisätä.

AddPath(GrafiikkaPath, Bool)

Liitä määritetty Aspose.Imaging.GraphicsPath tähän reittiin.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Aspose.Imaging.GraphicsPath lisätä.

connect bool

Boolean-arvo, joka määrittelee, onko lisätyn tien ensimmäinen numero tämän tien viimeisen kuvan osa.Totuuden arvo määrittelee, että lisätyn tien ensimmäinen numero on tämän tien viimeisen kuvan osa.Totuuden arvo määrittelee, että lisätyn tien ensimmäinen numero on erillään tämän tien viimeisestä kuudesta.

DeepClone()

Se suorittaa tämän graafisen polun syvän kloonin.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Grafiikan reitin syvä kloni.

Equals(Objekti)

Tarkista, ovatko kohteet tasa-arvoisia

public override bool Equals(object obj)

Parameters

obj object

Toinen esine on.

Returns

bool

Yhdenvertaisuus on tulos.

Flatten()

Se muuntaa jokaisen kurkun tällä reitillä yhdistettyjen linja-segmenttien järjestykseen.

public void Flatten()

Flatten(Matrix)

Soveltaa määriteltyä muuntamista ja muuntaa sitten jokainen kurkku tässä Aspose.Imaging.GraphicsPathin yhteenliittyneiden linja-segmenttien järjestykseen.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Aspose.Imaging.Matrix, jonka avulla voit muuntaa tämän WR17.GraphicsPath ennen flattening.

Flatten(Matrix ja Float)

Se muuntaa jokaisen kurkun tässä Aspose.Imaging.GraphicsPathin yhteen liitettyjen linja-segmenttien järjestykseen.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Aspose.Imaging.Matrix, jonka avulla voit muuntaa tämän WR17.GraphicsPath ennen flattening.

flatness float

Määrittää sallittu virhe kurkun ja sen tasaisen lähentymisen välillä. 0.25: n arvo on oletusarvo. tasaisuuden arvon vähentäminen lisää lähentymisen rivisegmenttien lukumäärää.

GetBounds(Matrix)

Kohtaa kohteen rajat.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

Matriisi, jota sovelletaan ennen rajoja, lasketaan.

Returns

RectangleF

arvioidun kohteen rajat.

GetBounds(Matrix ja Pen)

Kohtaa kohteen rajat.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

Matriisi, jota sovelletaan ennen rajoja, lasketaan.

pen Pen

Tämä voi vaikuttaa kohteen rajojen koon.

Returns

RectangleF

arvioidun kohteen rajat.

GetHashCode()

Hanki nykyisen kohteen hash-koodi.

public override int GetHashCode()

Returns

int

ja hash koodi.

IsOutlineVisible(laukaus, laukaus ja penni)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä ( alla), kun se on piirretty määritetyllä Wl17.Penillä.

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

Parameters

x float

x-koordinaatti pisteen testata.

y float

Y-koordinaatti pisteen testata.

pen Pen

Aspose.Imaging.Pen on testattava.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kun se on vetäytynyt määritetyillä WR17.Penillä; muutoin väärä.

IsOutlineVisible(Painajainen, Pen)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä ( alla), kun se on piirretty määritetyllä Wl17.Penillä.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Aspose.Imaging.PointF, joka määrittää paikan testata varten.

pen Pen

Aspose.Imaging.Pen on testattava.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kun se on vetäytynyt määritetyillä WR17.Penillä; muutoin väärä.

IsOutlineVisible(Float, Float, Pen, Grafiikka)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella), kun se on otettu määritetyllä __ WL16__ .Penillä ja käytetään määrittelemää _wL15.

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

Parameters

x float

x-koordinaatti pisteen testata.

y float

Y-koordinaatti pisteen testata.

pen Pen

Aspose.Imaging.Pen on testattava.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palauttaa totuuden, jos määritetty piste on sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella) niin kuin se on piirretty määritetyllä __ WL16_.Penillä; muutoin väärä.

IsOutlineVisible(PointF, Pen ja Grafiikka)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella), kun se on otettu määritetyllä __ WL16__ .Penillä ja käytetään määrittelemää _wL15.

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

Parameters

pt PointF

Aspose.Imaging.PointF, joka määrittää paikan testata varten.

pen Pen

Aspose.Imaging.Pen on testattava.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palauttaa totuuden, jos määritetty piste on sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella) niin kuin se on piirretty määritetyllä __ WL16_.Penillä; muutoin väärä.

IsOutlineVisible(Inti, Inti ja Pen)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä ( alla), kun se on piirretty määritetyllä Wl17.Penillä.

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

Parameters

x int

x-koordinaatti pisteen testata.

y int

Y-koordinaatti pisteen testata.

pen Pen

Aspose.Imaging.Pen on testattava.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kun se on vetäytynyt määritetyillä WR17.Penillä; muutoin väärä.

IsOutlineVisible(Pääosat, Pen)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä ( alla), kun se on piirretty määritetyllä Wl17.Penillä.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Aspose.Imaging.Piste, joka määrittää paikan testata.

pen Pen

Aspose.Imaging.Pen on testattava.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kun se on vetäytynyt määritetyillä WR17.Penillä; muutoin väärä.

IsOutlineVisible(int, int, pen, grafiikka)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella), kun se on otettu määritetyllä __ WL16__ .Penillä ja käytetään määrittelemää _wL15.

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

Parameters

x int

x-koordinaatti pisteen testata.

y int

Y-koordinaatti pisteen testata.

pen Pen

Aspose.Imaging.Pen on testattava.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kuten eritellyllä WR17.Pen; muutoin se on väärä.

IsOutlineVisible(Pisteet, Pen, Grafiikka)

Se osoittaa, onko määritelty kohde sisällytetty tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä (alapuolella), kun se on otettu määritetyllä __ WL16__ .Penillä ja käytetään määrittelemää _wL15.

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

Parameters

pt Point

Aspose.Imaging.Piste, joka määrittää paikan testata.

pen Pen

Aspose.Imaging.Pen on testattava.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty kohde on tämän Aspose.Imaging.GraphicsPathin ulottuvuuden sisällä, kuten eritellyllä WR17.Pen; muutoin se on väärä.

IsVisible(Laivasto, laivasto)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

x-koordinaatti pisteen testata.

y float

Y-koordinaatti pisteen testata.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(PointF)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Aspose.Imaging.PointF, joka edustaa testipisteitä.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(Sisä, sisä)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

x-koordinaatti pisteen testata.

y int

Y-koordinaatti pisteen testata.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(Point)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Aspose.Imaging.Piste, joka edustaa tarkistettavaa kohtaa.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(laiva, laiva ja grafiikka)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath näkyvässä kappalealueessa määritetystä WR17.

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

Parameters

x float

x-koordinaatti pisteen testata.

y float

Y-koordinaatti pisteen testata.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(PointF ja grafiikka)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Aspose.Imaging.PointF, joka edustaa testipisteitä.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tähän; muuten, väärä.

IsVisible(Inti, Inti ja Grafiikka)

Se osoittaa, onko määritelty kohde tässä Aspose.Imaging.GraphicsPathissa, käyttämällä määritetystä WR17.

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

Parameters

x int

x-koordinaatti pisteen testata.

y int

Y-koordinaatti pisteen testata.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

IsVisible(Piste ja grafiikka)

Se osoittaa, onko määritellyn pisteen sisältö tässä Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Aspose.Imaging.Piste, joka edustaa tarkistettavaa kohtaa.

graphics Graphics

Aspose.Imaging.Grafiikka, jonka näkyvyyden testaaminen.

Returns

bool

Tämä menetelmä palautuu totta, jos määritetty piste on sisällytetty tässä Aspose.Imaging.GraphicsPath; muuten, väärä.

RemoveFigure(Figure)

Poista yksi luku.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Määrä on poistettava.

RemoveFigures(Figure[])

Poistaa numerot

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure []

Numerot on poistettava.

Reset()

Käynnistä graafinen reitti ja aseta Aspose.Imaging.FillMode _www.fillmode.

public void Reset()

Reverse()

Se kääntää kuvien, muotojen ja pisteiden järjestyksen kunkin tämän Aspose.Imaging.GraphicsPathin muodossa.

public void Reverse()

Transform(Matrix)

Sovelletaan määriteltyä muuntamista muotoon.

public override void Transform(Matrix transform)

Parameters

transform Matrix

Muutos on sovellettava.

Warp(PointF[], ja RectangleF)

Soveltaa kierrätysmuodostusta, joka määritellään rektangulla ja rinnakkaisohjelmalla, tähän Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Aspose.Imaging.PointF-rakenteiden sarja, joka määrittelee parallelogrammin, johon srcRect’ määritelty oikea kulma muuttuu. sarjan voi sisältää joko kolme tai neljä elementtiä. Jos sarjassa on kolme elementtia, paralelogramin alempi oikean kulman edellyttää ensimmäiset kolme pistettä.

srcRect RectangleF

Aspose.Imaging.RectangleF, joka edustaa oikea kulma, jota muutetaan destPoints" määrittelemään rinnakkaiskirjaan.

Warp(PointF[], RectangleF ja Matrix)

Soveltaa kierrätysmuodostusta, joka määritellään rektangulla ja rinnakkaisohjelmalla, tähän Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Aspose.Imaging.PointF-rakenteiden sarja, joka määrittelee parallelogrammin, johon srcRect’ määritelty oikea kulma muuttuu. sarjan voi sisältää joko kolme tai neljä elementtiä. Jos sarjassa on kolme elementtia, paralelogramin alempi oikean kulman edellyttää ensimmäiset kolme pistettä.

srcRect RectangleF

Aspose.Imaging.RectangleF, joka edustaa oikea kulma, jota muutetaan destPoints" määrittelemään rinnakkaiskirjaan.

matrix Matrix

Aspose.Imaging.Matrix, joka määrittää geometrisen muutoksen, jota sovelletaan tielle.

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

Soveltaa kierrätysmuodostusta, joka määritellään rektangulla ja rinnakkaisohjelmalla, tähän Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Aspose.Imaging.PointF-rakenteiden sarja, joka määrittelee parallelogrammin, johon srcRect’ määritelty oikea kulma muuttuu. sarjalla voi olla joko kolme tai neljä elementtiä. Jos sarjassa on kolme elementtia, paralelogramin alempana oikealla kulmalla on ensimmäiset kolme pistettä.

srcRect RectangleF

Aspose.Imaging.RectangleF, joka edustaa oikea kulma, jota muutetaan destPoints" määrittelemään rinnakkaiskirjaan.

matrix Matrix

Aspose.Imaging.Matrix, joka määrittää geometrisen muutoksen, jota sovelletaan tielle.

warpMode WarpMode

Aspose.Imaging.WarpMode-luettelo, jossa määritetään, käytetäänkö tämä warp-toiminta näkökulmaa tai kahdenvälistä tilaa.

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

Soveltaa kierrätysmuodostusta, joka määritellään rektangulla ja rinnakkaisohjelmalla, tähän Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF []

Aspose.Imaging.PointF-rakenteiden sarja, joka määrittelee parallelogrammin, johon srcRect’ määritelty oikea kulma muuttuu. sarjan voi sisältää joko kolme tai neljä elementtiä. Jos sarjassa on kolme elementtia, paralelogramin alempi oikean kulman edellyttää ensimmäiset kolme pistettä.

srcRect RectangleF

Aspose.Imaging.RectangleF, joka edustaa oikea kulma, jota muutetaan destPoints" määrittelemään rinnakkaiskirjaan.

matrix Matrix

Aspose.Imaging.Matrix, joka määrittää geometrisen muutoksen, jota sovelletaan tielle.

warpMode WarpMode

Aspose.Imaging.WarpMode-luettelo, jossa määritetään, käytetäänkö tämä warp-toiminta näkökulmaa tai kahdenvälistä tilaa.

flatness float

Arvo 0–1, joka määrittää, kuinka tasainen tuloksena oleva reitti on. Lisätietoja on kohdassa Aspose.Imaging.GraphicsPath.Flatten menetelmät.

Widen(Pen)

Lisää lisäluettelon reitille.

public void Widen(Pen pen)

Parameters

pen Pen

Aspose.Imaging.Pen, jossa määritetään reitin alkuperäisen lähtökohdan ja uuden lähtön välinen leveys, luo tämä menetelmä.

Widen(Matriisi ja Matriisi)

Lisää lisätunnus Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Aspose.Imaging.Pen, jossa määritetään reitin alkuperäisen lähtökohdan ja uuden lähtön välinen leveys, luo tämä menetelmä.

matrix Matrix

Aspose.Imaging.Matrix, joka määrittää muutoksen, jota sovelletaan reittiin ennen laajentumista.

Widen(Matriisi, Matriisi ja Float)

Vaihda tämä Aspose.Imaging.GraphicsPath kulmilla, jotka sulkevat alueen, joka täyttyy, kun tämä reitti on vetetty määritellyllä penellä.

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

Parameters

pen Pen

Aspose.Imaging.Pen, jossa määritetään reitin alkuperäisen lähtökohdan ja uuden lähtön välinen leveys, luo tämä menetelmä.

matrix Matrix

Aspose.Imaging.Matrix, joka määrittää muutoksen, jota sovelletaan reittiin ennen laajentumista.

flatness float

Arvo, joka määrittelee kurkkujen sujuvuuden.

 Suomi