Class GraphicsPath

Class GraphicsPath

Nombre del espacio: Aspose.Imaging Asamblea: Aspose.Imaging.dll (25.4.0)

Representa una serie de líneas y curvas conectadas. esta clase no puede ser heredada.

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

Inheritance

object ObjectWithBounds GraphicsPath

Miembros heredados

ObjectWithBounds.GetBounds(Matrix) ,y, ObjectWithBounds.GetBounds(Matrix, Pen) ,y, ObjectWithBounds.Transform(Matrix) ,y, ObjectWithBounds.Equals(object) ,y, ObjectWithBounds.GetHashCode() ,y, ObjectWithBounds.Bounds ,y, object.GetType() ,y, object.ToString() ,y, object.Equals(object?) ,y, object.Equals(object?, object?) ,y, object.ReferenceEquals(object?, object?) ,y, object.GetHashCode()

Examples

Estos ejemplos hacen uso de la clase GraphicsPath y Graphics para crear y manipular Figuras en una superficie de imagen. El ejemplo crea una nueva imagen (de tipo Tiff), limpia la superficie y atrae caminos con la ayuda de la clase GraphicsPath. Al final, el método DrawPath expuesto por la clase Graphics se llama a rendir los caminos en la superficie.

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

Inicia una nueva instancia de la clase Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Estos ejemplos hacen uso de la clase GraphicsPath y Graphics para crear y manipular Figuras en una superficie de imagen. El ejemplo crea una nueva imagen (de tipo Tiff), limpia la superficie y atrae caminos con la ayuda de la clase GraphicsPath. Al final, el método DrawPath expuesto por la clase Graphics se llama a rendir los caminos en la superficie.

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

Inicia una nueva instancia de la clase Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [][]

Las cifras que se inician.

GraphicsPath(Figure[][], El FillMode)

Inicia una nueva instancia de la clase Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [][]

Las cifras que se inician.

fillMode FillMode

El modo de relleno.

GraphicsPath(FillMode)

Inicia una nueva instancia de la clase Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

El modo de relleno.

Properties

Bounds

Recibe o establece los límites del objeto.

public override RectangleF Bounds { get; }

Valor de la propiedad

RectangleF

Figures

Tiene las cifras del camino.

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

Valor de la propiedad

Figure [][]

FillMode

Obtenga o establece una enumeración Aspose.Imaging.FillMode que determina cómo se llenan los interiores de las formas en este Aspose.Imaging.GraphicsPath.

public FillMode FillMode { get; set; }

Valor de la propiedad

FillMode

Methods

AddFigure(Figure)

Añade una nueva figura.

public void AddFigure(Figure figure)

Parameters

figure Figure

El número a añadir.

Examples

Estos ejemplos hacen uso de la clase GraphicsPath y Graphics para crear y manipular Figuras en una superficie de imagen. El ejemplo crea una nueva imagen (de tipo Tiff), limpia la superficie y atrae caminos con la ayuda de la clase GraphicsPath. Al final, el método DrawPath expuesto por la clase Graphics se llama a rendir los caminos en la superficie.

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

Añade nuevas cifras.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [][]

Las cifras a añadir.

Examples

Este ejemplo crea una nueva imagen y atrae una variedad de formas utilizando Figuras y GraphicsPath en la superficie de la imagen

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

Añade el Aspose.Imaging.GraphicsPath especificado a este camino.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

El Aspose.Imaging.GraphicsPath para añadir.

AddPath(Página de inicio, bool)

Añade el Aspose.Imaging.GraphicsPath especificado a este camino.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

El Aspose.Imaging.GraphicsPath para añadir.

connect bool

Un valor booleano que especifica si la primera figura en el camino añadido es parte de la última figura en este camino. Un valor de verdad especifica que la primera figura en el camino añadido es parte de la última figura en este camino. Un valor de falso especifica que la primera figura en el camino añadido es separada de la última figura en este camino.

DeepClone()

Performan una clona profunda de este camino gráfico.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Una clona profunda del camino gráfico.

Equals(Objeto)

Verifique si los objetos son iguales.

public override bool Equals(object obj)

Parameters

obj object

El otro objeto.

Returns

bool

El resultado de la igualdad.

Flatten()

Converta cada curva en este camino en una secuencia de segmentos de línea conectados.

public void Flatten()

Flatten(Matrix)

Aplique la transformación especificada y luego convierte cada curva en este Aspose.Imaging.GraphicsPath en una secuencia de segmentos de línea conectados.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix por el que transformar este Aspose.Imaging.GraphicsPath antes de flater.

Flatten(Matrix y Float)

Converta cada curva en este Aspose.Imaging.GraphicsPath en una secuencia de segmentos de línea conectados.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Un Aspose.Imaging.Matrix por el que transformar este Aspose.Imaging.GraphicsPath antes de flater.

flatness float

Especifica el error máximo permitido entre la curva y su aproximación plana. Un valor de 0.25 es el default. Reducir el valor de la plana aumentará el número de segmentos de línea en la aproximación.

GetBounds(Matrix)

Tiene los límites del objeto.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

La matrícula a aplicar antes de los límites se calcular.

Returns

RectangleF

Los límites del objeto estimado.

GetBounds(Matrix y Pen)

Tiene los límites del objeto.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

La matrícula a aplicar antes de los límites se calcular.

pen Pen

La pena para usar para el objeto. Esto puede influir en el tamaño de los límites del objeto.

Returns

RectangleF

Los límites del objeto estimado.

GetHashCode()

Obtenga el código hash del objeto actual.

public override int GetHashCode()

Returns

int

El código hash.

IsOutlineVisible(Plutón, Plutón y Pen)

Indica si el punto especificado está contenido dentro (bajo) de la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado.

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

Parameters

x float

El coordenado x del punto de prueba.

y float

El y-coordenado del punto a prueba.

pen Pen

El Aspose.Imaging.Pen para probar.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(Título, Pen)

Indica si el punto especificado está contenido dentro (bajo) de la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Un Aspose.Imaging.PointF que especifica la ubicación para probar.

pen Pen

El Aspose.Imaging.Pen para probar.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(float, float, pen, gráficos)

Indica si el punto especificado está contenido dentro de (bajo) la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado y utilizando el Aspose.Imaging.Graphics especificado.

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

Parameters

x float

El coordenado x del punto de prueba.

y float

El y-coordenado del punto a prueba.

pen Pen

El Aspose.Imaging.Pen para probar.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro (desde) de la salida de este Aspose.Imaging.GraphicsPath como se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(PointF, Pen, gráficos)

Indica si el punto especificado está contenido dentro de (bajo) la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado y utilizando el Aspose.Imaging.Graphics especificado.

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

Parameters

pt PointF

Un Aspose.Imaging.PointF que especifica la ubicación para probar.

pen Pen

El Aspose.Imaging.Pen para probar.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro (desde) de la salida de este Aspose.Imaging.GraphicsPath como se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(Int, Int y Pen)

Indica si el punto especificado está contenido dentro (bajo) de la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado.

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

Parameters

x int

El coordenado x del punto de prueba.

y int

El y-coordenado del punto a prueba.

pen Pen

El Aspose.Imaging.Pen para probar.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(El punto, el pen)

Indica si el punto especificado está contenido dentro (bajo) de la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Un Aspose.Imaging.Point que especifica la ubicación para probar.

pen Pen

El Aspose.Imaging.Pen para probar.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(int, int, pen, gráficos)

Indica si el punto especificado está contenido dentro de (bajo) la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado y utilizando el Aspose.Imaging.Graphics especificado.

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

Parameters

x int

El coordenado x del punto de prueba.

y int

El y-coordenado del punto a prueba.

pen Pen

El Aspose.Imaging.Pen para probar.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath como se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsOutlineVisible(Punto, Pen, gráficos)

Indica si el punto especificado está contenido dentro de (bajo) la descripción de este Aspose.Imaging.GraphicsPath cuando se trae con el Aspose.Imaging.Pen especificado y utilizando el Aspose.Imaging.Graphics especificado.

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

Parameters

pt Point

Un Aspose.Imaging.Point que especifica la ubicación para probar.

pen Pen

El Aspose.Imaging.Pen para probar.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de la salida de este Aspose.Imaging.GraphicsPath como se trae con el Aspose.Imaging.Pen especificado; de lo contrario, falso.

IsVisible(Float y Float)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

El coordenado x del punto de prueba.

y float

El y-coordenado del punto a prueba.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(Puntos)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Un Aspose.Imaging.PointF que representa el punto a prueba.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(El int, int)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

El coordenado x del punto de prueba.

y int

El y-coordenado del punto a prueba.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(Point)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Un Aspose.Imaging.Point que representa el punto a prueba.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(float, float, gráficos)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath en la región del clip visible del Aspose.Imaging.Graphics especificado.

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

Parameters

x float

El coordenado x del punto de prueba.

y float

El y-coordenado del punto a prueba.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(Pintura, gráficos)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Un Aspose.Imaging.PointF que representa el punto a prueba.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve verdadero si el punto especificado se contiene dentro de esto; de lo contrario, falso.

IsVisible(int, int, gráficos)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath, utilizando el Aspose.Imaging.Graphics especificado.

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

Parameters

x int

El coordenado x del punto de prueba.

y int

El y-coordenado del punto a prueba.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

IsVisible(Puntos, gráficos)

Indica si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Un Aspose.Imaging.Point que representa el punto a prueba.

graphics Graphics

El Aspose.Imaging.Grafica para la que probar la visibilidad.

Returns

bool

Este método vuelve cierto si el punto especificado se encuentra dentro de este Aspose.Imaging.GraphicsPath; de lo contrario, falso.

RemoveFigure(Figure)

Eliminar una figura.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

El número a eliminar.

RemoveFigures(Figure[])

Eliminar las cifras.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [][]

Las cifras a eliminar.

Reset()

Empate el camino gráfico y coloca el Aspose.Imaging.FillMode en Aspose.Imaging.FillMode.Alternate.

public void Reset()

Reverse()

Revierte el orden de las figuras, formas y puntos en cada forma de este Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Aplicar la transformación especificada a la forma.

public override void Transform(Matrix transform)

Parameters

transform Matrix

La transformación a aplicar.

Warp(Puntos[][], de RectangleF)

Aplicar una transformación de varpa, definida por un rectángulo y un paralelograma, a este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Una serie de estructuras de Aspose.Imaging.PointF que define un paralelograma al que se transforma el rectángulo definido por srcRect’.La serie puede contener tres o cuatro elementos.Si la serie contiene tres elementos, el ángulo inferior-derecha del paralelograma se implica por los tres primeros puntos.

srcRect RectangleF

Aspose.Imaging.RectangleF que representa el rectángulo que se transforma en el paralelograma definido por destPoints'.

Warp(Puntos[][], RectangleF y Matrix)

Aplicar una transformación de varpa, definida por un rectángulo y un paralelograma, a este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Una serie de estructuras de Aspose.Imaging.PointF que define un paralelograma al que se transforma el rectángulo definido por srcRect’.La serie puede contener tres o cuatro elementos.Si la serie contiene tres elementos, el ángulo inferior-derecha del paralelograma se implica por los tres primeros puntos.

srcRect RectangleF

Aspose.Imaging.RectangleF que representa el rectángulo que se transforma en el paralelograma definido por destPoints'.

matrix Matrix

Una Aspose.Imaging.Matrix que especifica una transformación geométrica para aplicarse al camino.

Warp(Puntos[][], RectangleF, Matrix y WarpMode)

Aplicar una transformación de varpa, definida por un rectángulo y un paralelograma, a este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Una serie de estructuras de Aspose.Imaging.PointF que define un paralelograma al que se transforma el rectángulo definido por srcRect’.La serie puede contener tres o cuatro elementos.Si la serie contiene tres elementos, el ángulo inferior-derecha del paralelograma se implica por los tres primeros puntos.

srcRect RectangleF

Aspose.Imaging.RectangleF que representa el rectángulo que se transforma en el paralelograma definido por destPoints'.

matrix Matrix

Una Aspose.Imaging.Matrix que especifica una transformación geométrica para aplicarse al camino.

warpMode WarpMode

Una lista de Aspose.Imaging.WarpMode que especifica si esta operación de warp utiliza la perspectiva o el modo bilateral.

Warp(Puntos[][], RectangleF, Matrix, WarpMode, float)

Aplicar una transformación de varpa, definida por un rectángulo y un paralelograma, a este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [][]

Una serie de estructuras de Aspose.Imaging.PointF que define un paralelograma al que se transforma el rectángulo definido por srcRect’.La serie puede contener tres o cuatro elementos.Si la serie contiene tres elementos, el ángulo inferior-derecha del paralelograma se implica por los tres primeros puntos.

srcRect RectangleF

Aspose.Imaging.RectangleF que representa el rectángulo que se transforma en el paralelograma definido por destPoints'.

matrix Matrix

Una Aspose.Imaging.Matrix que especifica una transformación geométrica para aplicarse al camino.

warpMode WarpMode

Una lista de Aspose.Imaging.WarpMode que especifica si esta operación de warp utiliza la perspectiva o el modo bilateral.

flatness float

Un valor de 0 a 1 que especifica cuán plano es el camino resultante.Para más información, vea los métodos de Aspose.Imaging.GraphicsPath.Flatten.

Widen(Pen)

Añade una salida adicional al camino.

public void Widen(Pen pen)

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica la anchura entre la salida original del camino y la nueva salida este método crea.

Widen(Peso y Matrix)

Añade un resumen adicional a Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica la anchura entre la salida original del camino y la nueva salida este método crea.

matrix Matrix

Una Aspose.Imaging.Matrix que especifica una transformación para aplicar al camino antes de ampliar.

Widen(Pen, Matrix y Float)

Reemplaza este Aspose.Imaging.GraphicsPath con curvas que incluyen la zona que se llena cuando este camino se atrae por la pena especificada.

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

Parameters

pen Pen

Un Aspose.Imaging.Pen que especifica la anchura entre la salida original del camino y la nueva salida este método crea.

matrix Matrix

Una Aspose.Imaging.Matrix que especifica una transformación para aplicar al camino antes de ampliar.

flatness float

Un valor que especifica la plana para las curvas.

 Español