Class GraphicsPath

Class GraphicsPath

Nome do espaço: Aspose.Imaging Assembleia: Aspose.Imaging.dll (25.4.0)

Representa uma série de linhas e curvas conectadas. esta classe não pode ser herdada.

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

Inheritance

object ObjectWithBounds GraphicsPath

Membros herdados

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

Esses exemplos usam a classe GraphicsPath e Graphics para criar e manipular Figuras em uma superfície da imagem. Exemplo cria uma nova imagem (do tipo Tiff), limpa a superfície e tira caminhos com a ajuda da classe GraphicsPath. No final, o método DrawPath exposto pela classe Graphics é chamado para render os caminhos na superfície.

//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 uma nova instância da classe Aspose.Imaging.GraphicsPath.

[JsonConstructor]
public GraphicsPath()

Examples

Esses exemplos usam a classe GraphicsPath e Graphics para criar e manipular Figuras em uma superfície da imagem. Exemplo cria uma nova imagem (do tipo Tiff), limpa a superfície e tira caminhos com a ajuda da classe GraphicsPath. No final, o método DrawPath exposto pela classe Graphics é chamado para render os caminhos na superfície.

//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 uma nova instância da classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures)

Parameters

figures Figure [ ]

Os números que devem ser iniciados.

GraphicsPath(Figure[ ], O FillMode)

Inicia uma nova instância da classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(Figure[] figures, FillMode fillMode)

Parameters

figures Figure [ ]

Os números que devem ser iniciados.

fillMode FillMode

O modo de enchimento.

GraphicsPath(FillMode)

Inicia uma nova instância da classe Aspose.Imaging.GraphicsPath.

public GraphicsPath(FillMode fillMode)

Parameters

fillMode FillMode

O modo de enchimento.

Properties

Bounds

Recebe ou coloca os limites do objeto.

public override RectangleF Bounds { get; }

Valor da propriedade

RectangleF

Figures

Conheça os números do caminho.

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

Valor da propriedade

Figure [ ]

FillMode

Obter ou definir uma lista de Aspose.Imaging.FillMode que determina como os interiores das formas neste Aspose.Imaging.GraphicsPath são preenchidos.

public FillMode FillMode { get; set; }

Valor da propriedade

FillMode

Methods

AddFigure(Figure)

Adicione uma nova figura.

public void AddFigure(Figure figure)

Parameters

figure Figure

A figura para adicionar.

Examples

Esses exemplos usam a classe GraphicsPath e Graphics para criar e manipular Figuras em uma superfície da imagem. Exemplo cria uma nova imagem (do tipo Tiff), limpa a superfície e tira caminhos com a ajuda da classe GraphicsPath. No final, o método DrawPath exposto pela classe Graphics é chamado para render os caminhos na superfície.

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

Adicione novos números.

public void AddFigures(Figure[] figures)

Parameters

figures Figure [ ]

Os números para adicionar.

Examples

Este exemplo cria uma nova imagem e tira uma variedade de formas usando Figuras e GraphicsPath na superfície da imagem

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

Adicione o Aspose.Imaging.GraphicsPath especificado para este caminho.

public void AddPath(GraphicsPath addingPath)

Parameters

addingPath GraphicsPath

O Aspose.Imaging.GraphicsPath para adicionar.

AddPath(GraphicsPath e Bool)

Adicione o Aspose.Imaging.GraphicsPath especificado para este caminho.

public void AddPath(GraphicsPath addingPath, bool connect)

Parameters

addingPath GraphicsPath

O Aspose.Imaging.GraphicsPath para adicionar.

connect bool

Um valor booleano que especifica se a primeira figura no caminho adicionado faz parte da última figura neste caminho. um valor de verdade especifica que a primeira figura no caminho adicionado faz parte da última figura neste caminho. um valor de falso especifica que a primeira figura no caminho adicionado é separada da última figura neste caminho.

DeepClone()

Performar um clone profundo deste caminho gráfico.

public GraphicsPath DeepClone()

Returns

GraphicsPath

Um clone profundo do caminho gráfico.

Equals(Objeto)

Verifique se os objetos são iguais.

public override bool Equals(object obj)

Parameters

obj object

O outro objeto.

Returns

bool

O resultado da comparação da igualdade.

Flatten()

Converte cada curva neste caminho em uma sequência de segmentos de linha conectados.

public void Flatten()

Flatten(Matrix)

Aplique a transformação especificada e, em seguida, converte cada curva neste Aspose.Imaging.GraphicsPath em uma sequência de segmentos de linha conectados.

public void Flatten(Matrix matrix)

Parameters

matrix Matrix

Um Aspose.Imaging.Matrix pelo qual transformar este Aspose.Imaging.GraphicsPath antes de flutuar.

Flatten(Matriz e Float)

Converte cada curva neste Aspose.Imaging.GraphicsPath em uma sequência de segmentos de linha conectados.

public void Flatten(Matrix matrix, float flatness)

Parameters

matrix Matrix

Um Aspose.Imaging.Matrix pelo qual transformar este Aspose.Imaging.GraphicsPath antes de flutuar.

flatness float

Especifica o erro máximo permitido entre a curva e a sua aproximação flatulente. um valor de 0.25 é o padrão. reduzir o valor de flatness aumentará o número de segmentos de linha na aproximação.

GetBounds(Matrix)

Conheça os limites do objeto.

public override RectangleF GetBounds(Matrix matrix)

Parameters

matrix Matrix

A matriz a aplicar antes dos limites será calculada.

Returns

RectangleF

Os limites do objeto estimado.

GetBounds(Matriz e Pen)

Conheça os limites do objeto.

public override RectangleF GetBounds(Matrix matrix, Pen pen)

Parameters

matrix Matrix

A matriz a aplicar antes dos limites será calculada.

pen Pen

A caneta para usar para o objeto. isto pode influenciar o tamanho dos limites do objeto.

Returns

RectangleF

Os limites do objeto estimado.

GetHashCode()

Obtenha o código hash do objeto atual.

public override int GetHashCode()

Returns

int

O código de hash.

IsOutlineVisible(Armadilha, Armadilha e Pen)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado.

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

Parameters

x float

O coordenado x do ponto a ser testado.

y float

A coordenada do ponto para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(Pessoa, Pessoa)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado.

public bool IsOutlineVisible(PointF point, Pen pen)

Parameters

point PointF

Um Aspose.Imaging.PointF que especifica a localização para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(Plutão, Plutão, Pen, Gráficos)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado e usando o Aspose.Imaging.Graphics especificado.

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

Parameters

x float

O coordenado x do ponto a ser testado.

y float

A coordenada do ponto para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro (sub) da linha de saída deste Aspose.Imaging.GraphicsPath como desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(PointF, Pen, gráficos)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado e usando o Aspose.Imaging.Graphics especificado.

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

Parameters

pt PointF

Um Aspose.Imaging.PointF que especifica a localização para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro (sub) da linha de saída deste Aspose.Imaging.GraphicsPath como desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(Int, Int e Pen)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado.

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

Parameters

x int

O coordenado x do ponto a ser testado.

y int

A coordenada do ponto para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(Pessoa, Pen)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado.

public bool IsOutlineVisible(Point point, Pen pen)

Parameters

point Point

Um Aspose.Imaging.Point que especifica a localização para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

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

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado e usando o Aspose.Imaging.Graphics especificado.

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

Parameters

x int

O coordenado x do ponto a ser testado.

y int

A coordenada do ponto para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath como desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsOutlineVisible(Pontos, Pen, Graphics)

Indica se o ponto especificado está contido dentro (abaixo) da redação deste Aspose.Imaging.GraphicsPath quando desenhado com o Aspose.Imaging.Pen especificado e usando o Aspose.Imaging.Graphics especificado.

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

Parameters

pt Point

Um Aspose.Imaging.Point que especifica a localização para testar.

pen Pen

O Aspose.Imaging.Pen para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro do outline deste Aspose.Imaging.GraphicsPath como desenhado com o Aspose.Imaging.Pen especificado; caso contrário, falso.

IsVisible(Flóia, Flóia)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(float x, float y)

Parameters

x float

O coordenado x do ponto a ser testado.

y float

A coordenada do ponto para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(pontof)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF point)

Parameters

point PointF

Um Aspose.Imaging.PointF que representa o ponto a ser testado.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(Int, Int)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(int x, int y)

Parameters

x int

O coordenado x do ponto a ser testado.

y int

A coordenada do ponto para testar.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(Point)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point point)

Parameters

point Point

Um Aspose.Imaging.Point que representa o ponto a ser testado.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(Flotas, Flotas e gráficos)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath na região de clipe visível do Aspose.Imaging.Graphics especificado.

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

Parameters

x float

O coordenado x do ponto a ser testado.

y float

A coordenada do ponto para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(Avaliações, Graphics)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(PointF pt, Graphics graphics)

Parameters

pt PointF

Um Aspose.Imaging.PointF que representa o ponto a ser testado.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado está contido dentro deste; caso contrário, falso.

IsVisible(int, int, gráficos)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath, usando o Aspose.Imaging.Graphics especificado.

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

Parameters

x int

O coordenado x do ponto a ser testado.

y int

A coordenada do ponto para testar.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

IsVisible(ponto, gráficos)

Indica se o ponto especificado está contido dentro deste Aspose.Imaging.GraphicsPath.

public bool IsVisible(Point pt, Graphics graphics)

Parameters

pt Point

Um Aspose.Imaging.Point que representa o ponto a ser testado.

graphics Graphics

A Aspose.Imaging.Grafica para a qual testar a visibilidade.

Returns

bool

Este método torna-se verdadeiro se o ponto especificado for contido dentro deste Aspose.Imaging.GraphicsPath; caso contrário, falso.

RemoveFigure(Figure)

Remova uma figura.

public void RemoveFigure(Figure figure)

Parameters

figure Figure

A figura a ser removida.

RemoveFigures(Figure[])

Remova os números.

public void RemoveFigures(Figure[] figures)

Parameters

figures Figure [ ]

Os números a serem removidos.

Reset()

Emprega o caminho gráfico e coloca o Aspose.Imaging.FillMode para Aspose.Imaging.FillMode.Alternate.

public void Reset()

Reverse()

Revira a ordem de figuras, formas e pontos em cada forma deste Aspose.Imaging.GraphicsPath.

public void Reverse()

Transform(Matrix)

Aplique a transformação especificada à forma.

public override void Transform(Matrix transform)

Parameters

transform Matrix

A transformação a ser aplicada.

Warp(pontof[ ], e RectangleF)

Aplique uma transformação de varpa, definida por um rectangulo e um paralelograma, para este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Uma série de Aspose.Imaging.PointF estruturas que definem um paralelograma para o qual o rectangulo definido por srcRect’ é transformado. A série pode conter três ou quatro elementos. Se a série contém três elementos, o canto inferior-direita do paralelograma é implicado pelos três primeiros pontos.

srcRect RectangleF

Um Aspose.Imaging.RectangleF que representa o rectangle que é transformado no paralelograma definido por destPoints'.

Warp(pontof[ ], RectangleF, Matriz)

Aplique uma transformação de varpa, definida por um rectangulo e um paralelograma, para este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Uma série de Aspose.Imaging.PointF estruturas que definem um paralelograma para o qual o rectangulo definido por srcRect’ é transformado. A série pode conter três ou quatro elementos. Se a série contém três elementos, o canto inferior-direita do paralelograma é implicado pelos três primeiros pontos.

srcRect RectangleF

Um Aspose.Imaging.RectangleF que representa o rectangle que é transformado no paralelograma definido por destPoints'.

matrix Matrix

Um Aspose.Imaging.Matrix que especifica uma transformação geométrica para aplicar ao caminho.

Warp(pontof[ ], RectangleF, Matrix e WarpMode)

Aplique uma transformação de varpa, definida por um rectangulo e um paralelograma, para este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Uma série de estruturas Aspose.Imaging.PointF que define um paralelograma para o qual o rectangulo definido por srcRect’ é transformado.A série pode conter três ou quatro elementos.Se a série contém três elementos, o canto inferior-direita do paralelograma é implicado pelos três primeiros pontos.

srcRect RectangleF

Um Aspose.Imaging.RectangleF que representa o rectangle que é transformado no paralelograma definido por destPoints'.

matrix Matrix

Um Aspose.Imaging.Matrix que especifica uma transformação geométrica para aplicar ao caminho.

warpMode WarpMode

Uma lista de Aspose.Imaging.WarpMode que especifica se esta operação de warp usa o modo de perspectiva ou bilinear.

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

Aplique uma transformação de varpa, definida por um rectangulo e um paralelograma, para este Aspose.Imaging.GraphicsPath.

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

Parameters

destPoints PointF [ ]

Uma série de Aspose.Imaging.PointF estruturas que definem um paralelograma para o qual o rectangulo definido por srcRect’ é transformado. A série pode conter três ou quatro elementos. Se a série contém três elementos, o canto inferior-direita do paralelograma é implicado pelos três primeiros pontos.

srcRect RectangleF

Um Aspose.Imaging.RectangleF que representa o rectangle que é transformado no paralelograma definido por destPoints'.

matrix Matrix

Um Aspose.Imaging.Matrix que especifica uma transformação geométrica para aplicar ao caminho.

warpMode WarpMode

Uma lista de Aspose.Imaging.WarpMode que especifica se esta operação de warp usa o modo de perspectiva ou bilinear.

flatness float

Um valor de 0 a 1 que especifica o quão plano o caminho resultante é. para mais informações, consulte os métodos Aspose.Imaging.GraphicsPath.Flatten.

Widen(Pen)

Adicione uma saída adicional ao caminho.

public void Widen(Pen pen)

Parameters

pen Pen

Um Aspose.Imaging.Pen que especifica a largura entre a saída original do caminho e a nova saída este método cria.

Widen(Pênis e Matrix)

Adicione um resumo adicional ao Aspose.Imaging.GraphicsPath.

public void Widen(Pen pen, Matrix matrix)

Parameters

pen Pen

Um Aspose.Imaging.Pen que especifica a largura entre a saída original do caminho e a nova saída este método cria.

matrix Matrix

Um Aspose.Imaging.Matrix que especifica uma transformação para aplicar ao caminho antes de expandir.

Widen(Pen, Matrix e Float)

Substitui este Aspose.Imaging.GraphicsPath com curvas que encerram a área que é preenchida quando este caminho é desenhado pela caneta especificada.

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

Parameters

pen Pen

Um Aspose.Imaging.Pen que especifica a largura entre a saída original do caminho e a nova saída este método cria.

matrix Matrix

Um Aspose.Imaging.Matrix que especifica uma transformação para aplicar ao caminho antes de expandir.

flatness float

Um valor que especifica a plana para as curvas.

 Português