Class GraphicsPath

Class GraphicsPath

Il nome: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.4.0)

Si tratta di una serie di linee e curve connesse.Questa classe non può essere ereditata.

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

Inheritance

object ObjectWithBounds GraphicsPath

I membri ereditari

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

Questi esempi utilizzano la classe GraphicsPath e la grafica per creare e manipolare le figure su una superficie dell’immagine. Esempio crea una nuova Immagine (di tipo Tiff), pulisce la superficie e traccia i percorsi con l’aiuto della classe Grafica.

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

Inizia una nuova instanza della classe Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Questi esempi utilizzano la classe GraphicsPath e la grafica per creare e manipolare le figure su una superficie dell’immagine. Esempio crea una nuova Immagine (di tipo Tiff), pulisce la superficie e traccia i percorsi con l’aiuto della classe Grafica.

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

Inizia una nuova instanza della classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [ ]

I numeri da inizializzare.

GraphicsPath(Figure[ ], di FillMode)

Inizia una nuova instanza della classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [ ]

I numeri da inizializzare.

fillMode FillMode

La modalità di riempimento.

GraphicsPath(FillMode)

Inizia una nuova instanza della classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

La modalità di riempimento.

Properties

Bounds

Riceve o mette i confini dell’oggetto.

public override RectangleF Bounds { get; }

Valore di proprietà

RectangleF

Figures

Scopri i numeri del percorso.

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

Valore di proprietà

Figure [ ]

FillMode

Riceve o impone un elenco di Aspose.Imaging.FillMode che determina come vengono compilati gli interni delle forme in questo Wl17.GraphicsPath.

public FillMode FillMode { get; set; }

Valore di proprietà

FillMode

Methods

AddFigure(Figure)

Aggiungi una nuova figura.

public void AddFigure(Figure figure)

Parameters

figure Figure

Il numero da aggiungere.

Examples

Questi esempi utilizzano la classe GraphicsPath e la grafica per creare e manipolare le figure su una superficie dell’immagine. Esempio crea una nuova Immagine (di tipo Tiff), pulisce la superficie e traccia i percorsi con l’aiuto della classe Grafica.

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

Aggiungi nuove cifre.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [ ]

I numeri da aggiungere.

Examples

Questo esempio crea una nuova Immagine e attira una varietà di forme utilizzando Figure e GraphicsPath sulla superficie dell’Imagine

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

Aggiungi il Aspose.Imaging.GraphicsPath specificato a questo percorso.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

Il Aspose.Imaging.GraphicsPath per aggiungere.

AddPath(Giochi di Giochi, Bool)

Aggiungi il Aspose.Imaging.GraphicsPath specificato a questo percorso.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

Il Aspose.Imaging.GraphicsPath per aggiungere.

connect bool

Un valore booleano che specifica se la prima figura nel percorso aggiunto fa parte dell’ultima figura in questo percorso. Un valore di vero specifica che la prima figura nel percorso aggiunto fa parte dell’ultima figura in questo percorso. Un valore di falso specifica che la prima figura nel percorso aggiunto è separata dall’ultima figura in questo percorso.

DeepClone()

Realizza un profondo clone di questo percorso grafico.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Un profondo clone del percorso grafico.

Equals(oggetto)

Verificare se gli oggetti sono uguali.

public override bool Equals(object obj)

Parameters

obj object

L’altro oggetto

Returns

bool

Il risultato della comparsa di uguaglianza.

Flatten()

Converte ogni curva in questo percorso in una sequenza di segmenti di linea collegati.

public void Flatten()

Flatten(Matrix)

Applica la trasformazione specificata e poi converte ogni curva in questo Aspose.Imaging.GraphicsPath in una sequenza di segmenti di linea collegati.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix per il quale trasformare questo Wl17.GraphicsPath prima di flattare.

Flatten(Matrix e Float)

Converte ogni curva in questo Aspose.Imaging.GraphicsPath in una sequenza di segmenti di linea collegati.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix per il quale trasformare questo Wl17.GraphicsPath prima di flattare.

flatness float

Determinare l’errore massimo permesso tra la curva e la sua approcciazione flattata. Un valore di 0.25 è il default. Ridurre il valore di flessibilità aumenterà il numero di segmenti di linea nell’approccio.

GetBounds(Matrix)

Riceve i limiti dell’oggetto.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

La matrice da applicare prima dei limiti sarà calcolata.

Returns

RectangleF

I limiti dell’oggetto stimato.

GetBounds(Matrix e Pen)

Riceve i limiti dell’oggetto.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

La matrice da applicare prima dei limiti sarà calcolata.

pen Pen

La penna da usare per l’oggetto. Questo può influenzare la dimensione dei confini dell’oggetto.

Returns

RectangleF

I limiti dell’oggetto stimato.

GetHashCode()

Ottieni il codice hash dell’oggetto attuale.

public override int GetHashCode()

Returns

int

Il codice hash.

IsOutlineVisible(Sviluppo, Sviluppo e Pen)

Indica se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen.

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen; altrimenti, falso.

IsOutlineVisible(Il punto, il pen)

Indica se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Un Aspose.Imaging.PointF che specifica la posizione da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen; altrimenti, falso.

IsOutlineVisible(Flotta, flotta, penna, grafica)

Indica se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specificato Wl17.Pen e utilizzando il specificato _ www.grafica.it .

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con il specifico __ WL16_.Pen; altrimenti, falso.

IsOutlineVisible(PointF, Pen, Grafica)

Indica se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specificato Wl17.Pen e utilizzando il specificato _ www.grafica.it .

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

Parameters

pt PointF

Un Aspose.Imaging.PointF che specifica la posizione da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con il specifico __ WL16_.Pen; altrimenti, falso.

IsOutlineVisible(di int, int, pen)

Indica se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen.

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen; altrimenti, falso.

IsOutlineVisible(Il punto, il pen)

Indica se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Un Aspose.Imaging.Punto che specifica la posizione da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specifico WR17.Pen; altrimenti, falso.

IsOutlineVisible(int, int, pen, grafica)

Indica se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specificato Wl17.Pen e utilizzando il specificato _ www.grafica.it .

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con il specifico WR17.Pen; altrimenti, falso.

IsOutlineVisible(Il punto, la penna, la grafica)

Indica se il punto specificato è contenuto all’interno (in basso) dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con il specificato Wl17.Pen e utilizzando il specificato _ www.grafica.it .

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

Parameters

pt Point

Un Aspose.Imaging.Punto che specifica la posizione da testare.

pen Pen

Il Aspose.Imaging.Pen per testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna valido se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con il specifico WR17.Pen; altrimenti, falso.

IsVisible(La flotta, la flotta)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(di PointF)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Un Aspose.Imaging.PointF che rappresenta il punto da testare.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(di int, int)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(Point)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Un Aspose.Imaging.Punto che rappresenta il punto da testare.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(flotta, flotta e grafica)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath nella regione del clip visibile del specifico __ WL16_.

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

Parameters

x float

Il coordinato x del punto da testare.

y float

L’e-coordinato del punto da testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(Il punto, la grafica)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF che rappresenta il punto da testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto dentro di esso; altrimenti, falso.

IsVisible(int, int, grafica)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath, utilizzando l’indicato WR17.

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

Parameters

x int

Il coordinato x del punto da testare.

y int

L’e-coordinato del punto da testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

IsVisible(Il punto, la grafica)

Indica se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.Punto che rappresenta il punto da testare.

graphics Graphics

La Aspose.Imaging.Grafica per la quale testare la visibilità.

Returns

bool

Questo metodo ritorna vero se il punto specificato è contenuto all’interno di questo Aspose.Imaging.GraphicsPath; altrimenti, falso.

RemoveFigure(Figure)

Rimuovere una figura.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

Il numero da rimuovere.

RemoveFigures(Figure[])

Rimuovere le cifre.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [ ]

I numeri da rimuovere.

Reset()

Inserisci il percorso grafico e impostare il Aspose.Imaging.FillMode a Wl17.

public void Reset()

Reverse()

Invertisce l’ordine di figure, forme e punti in ogni forma di questo Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Applicare la trasformazione specificata alla forma.

public override void Transform(Matrix transform)

Parameters

transform Matrix

La trasformazione da applicare.

Warp(di PointF[ ], di RectangleF)

Applica una trasformazione di warp, definita da un rettangolo e un parallelogramma, a questo Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Una riga di Aspose.Imaging.PointF strutture che definisce un parallelogramma al quale il rettangolo definito da srcRect’ è trasformato. l’area può contenere sia tre o quattro elementi. se l’area contiene tre elementi, il angolo inferiore a destra del parallelo è implicato dai primi tre punti.

srcRect RectangleF

Un Aspose.Imaging.RectangleF che rappresenta il rettangolo che viene trasformato nel parallelogramma definito da destPoints".

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

Applica una trasformazione di warp, definita da un rettangolo e un parallelogramma, a questo Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Una riga di Aspose.Imaging.PointF strutture che definisce un parallelogramma al quale il rettangolo definito da srcRect’ è trasformato. l’area può contenere sia tre o quattro elementi. se l’area contiene tre elementi, il angolo inferiore a destra del parallelo è implicato dai primi tre punti.

srcRect RectangleF

Un Aspose.Imaging.RectangleF che rappresenta il rettangolo che viene trasformato nel parallelogramma definito da destPoints".

matrix Matrix

Un Aspose.Imaging.Matrix che specifica una trasformazione geometrica da applicare al percorso.

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

Applica una trasformazione di warp, definita da un rettangolo e un parallelogramma, a questo Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Una serie di strutture Aspose.Imaging.PointF che definisce un parallelogramma al quale è trasformato il rectangolo definito da srcRect’.La serie può contenere tre o quattro elementi.

srcRect RectangleF

Un Aspose.Imaging.RectangleF che rappresenta il rettangolo che viene trasformato nel parallelogramma definito da destPoints".

matrix Matrix

Un Aspose.Imaging.Matrix che specifica una trasformazione geometrica da applicare al percorso.

warpMode WarpMode

Un Aspose.Imaging.WarpMode elenco che specifica se questa operazione di warp utilizza il modo prospettivo o bilingue.

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

Applica una trasformazione di warp, definita da un rettangolo e un parallelogramma, a questo Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Una riga di Aspose.Imaging.PointF strutture che definisce un parallelogramma al quale il rettangolo definito da srcRect’ è trasformato. l’area può contenere sia tre o quattro elementi. se l’area contiene tre elementi, il angolo inferiore a destra del parallelo è implicato dai primi tre punti.

srcRect RectangleF

Un Aspose.Imaging.RectangleF che rappresenta il rettangolo che viene trasformato nel parallelogramma definito da destPoints".

matrix Matrix

Un Aspose.Imaging.Matrix che specifica una trasformazione geometrica da applicare al percorso.

warpMode WarpMode

Un Aspose.Imaging.WarpMode elenco che specifica se questa operazione di warp utilizza il modo prospettivo o bilingue.

flatness float

Un valore da 0 a 1 che specifica quanto è piatto il percorso risultante. per ulteriori informazioni, vedere il Aspose.Imaging.GraphicsPath.Flatten metodi.

Widen(Pen)

Aggiungi un’ulteriore traccia al percorso.

public void Widen(Pen pen)

Parameters

pen Pen

Un Aspose.Imaging.Pen che specifica la larghezza tra la linea di partenza originale del percorso e la nuova linea questo metodo crea.

Widen(Il Pen, Matrix)

Aggiungi un’ulteriore estensione al Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Un Aspose.Imaging.Pen che specifica la larghezza tra la linea di partenza originale del percorso e la nuova linea questo metodo crea.

matrix Matrix

Un Aspose.Imaging.Matrix che specifica una trasformazione da applicare al percorso prima dell’espansione.

Widen(Pen, Matrix e Float)

Sostituisce questo Aspose.Imaging.GraphicsPath con curve che chiudono l’area che viene riempita quando questo percorso è ritratto dalla penna specificata.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen che specifica la larghezza tra la linea di partenza originale del percorso e la nuova linea questo metodo crea.

matrix Matrix

Un Aspose.Imaging.Matrix che specifica una trasformazione da applicare al percorso prima dell’espansione.

flatness float

Un valore che specifica la flessibilità per le curve.

 Italiano