Class GraphicsPath
Il nome: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.5.0)
Si tratta di una serie di linee e curve connesse.Questa classe non può essere ereditata.
[JsonObject(MemberSerialization.OptIn)]
public sealed class GraphicsPath : ObjectWithBoundsInheritance
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à
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 sono riempiti gli interni delle forme in questo Asposa.Immagning.GraphicsPath.
public FillMode FillMode { get; set; }Valore di proprietà
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
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
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 con il quale trasformare questo Asposa.Imagino.GraficaPath 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 con il quale trasformare questo Asposa.Imagino.GraficaPath 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
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
I limiti dell’oggetto stimato.
GetHashCode()
Ottieni il codice hash dell’oggetto attuale.
public override int GetHashCode()Returns
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 l’aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con l’aspetto specifico Asposa.Imagine.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 l’aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con l’aspetto specifico Asposa.Imagine.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 l’aspetto specifico e utilizzando lo aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con l’aspetto specifico Asposa.Immagning.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 l’aspetto specifico e utilizzando lo aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno (sotto) dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con l’aspetto specifico Asposa.Immagning.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 l’aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con l’aspetto specifico Asposa.Imagine.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 l’aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath quando ritratto con l’aspetto specifico Asposa.Imagine.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 l’aspetto specifico e utilizzando lo aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con l’aspetto specifico Asposa.Imagine.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 l’aspetto specifico e utilizzando lo aspetto specifico.
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
Questo metodo ritorna vero se il punto specificato è contenuto all’interno dell’outline di questo Aspose.Imaging.GraphicsPath come ritratto con l’aspetto specifico Asposa.Imagine.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
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
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
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
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 dell’aspetto specifico.
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
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
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’aspetto specifico.
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
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
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 Aspose.Imaging.FillMode in Asposa.Imaginare.
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.