logo
Helpful resources ▼
  PyPi   Pricing   Buy

Trabajar con degradado en un archivo PS | Pitón

Agregar degradado en documento PS

Este artículo explora la implementación de gradientes en documentos PS usando Aspose.Page para Python.

Los degradados representan una transición suave entre colores, mejorando el realismo de las imágenes dibujadas.

En Aspose.Page para Python, los gradientes se implementan como subclases de aspose.pydrawing.Brush, a saber:

Para aplicar pintura o trazo en un PsDocument, los objetos de la clase aspose.pydrawing.Brush para pintar y aspose.pydrawing.Pen para trazar se pasan a los métodos respectivos. Aspose.Page para Python admite todas las clases esenciales dentro de aspose.pydrawing.Brush ofrecidas por la plataforma .NET, incluidas aspose.pydrawing.Color, aspose.pydrawing.TextureBrush, aspose.pydrawing.drawing2d .LinearGradientBrush y aspose.pydrawing.drawing2d.PathGradientBrush. El color del trazo se asigna por separado de las propiedades del trazo usando aspose.pydrawing.Brush en el objeto aspose.pydrawing.Pen.

Para pintar objetos gráficos con un degradado, cree aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush y páselo a set_paint() o uno de los métodos fill_text() o fill_and_stroke_text(), que aceptan aspose.pydrawing.Brush como parámetro.

Para delinear objetos gráficos con un degradado, pase aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush a set_paint() o uno de los * Métodos outline_text()* o fill_and_stroke_text(), que aceptan trazos de pintura como parámetro.

En el siguiente ejemplo, demostramos cómo rellenar una forma y un texto y delinear el texto con un degradado.

Un algoritmo para pintar objetos gráficos con un degradado en un nuevo documento PS incluye los siguientes pasos:

  1. Cree una secuencia de salida para el archivo PS resultante.
  2. Inicie PsSaveOptions.
  3. Cree un PsDocument con el flujo de salida ya creado y las opciones de guardado.
  4. Cree la ruta gráfica necesaria o una fuente dependiendo del objeto que vamos a rellenar o delinear.
  5. Cree un objeto de aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush dependiendo de la forma deseada de un degradado.
  6. Establezca la transformación necesaria en este pincel.
  7. Establezca el pincel de degradado como la pintura actual en PsDocument.
  8. Rellene la ruta de los gráficos con la pintura actual o rellene el texto. Si utilizamos uno de los métodos para rellenar el texto que acepta aspose.pydrawing.Brush como parámetro, se puede ignorar el paso anterior.
  9. Cierra la página.
  10. Guarde el documento.

Si necesitamos trazar (delinear) objetos gráficos con un degradado en lugar de los últimos 4 pasos, el aspecto será el siguiente:

  1. Establezca el degradado como pintura actual en PsDocument.
  2. Cree el objeto aspose.pydrawing.Pen.
  3. Establezca este trazo como el trazo actual en PsDocument.
  4. Delinee la ruta de los gráficos con el trazo actual o delinee el texto. Si utilizamos uno de los métodos para delinear el texto que acepta aspose.pydrawing.Pen como parámetro, se puede ignorar el punto anterior.
  5. Cierra la página.
  6. Guarde el documento.

Aquí hay 5 fragmentos de código separados que demuestran el uso de diferentes gradientes. En este creamos un degradado lineal horizontal a partir de dos colores, rellenamos un rectángulo, rellenamos un texto, delineamos un texto con este degradado.

 1# The path to the documents directory.
 2data_dir = Util.get_data_dir_working_with_gradient()
 3
 4# Create an output stream for the PostScript document
 5with open(data_dir + "HorizontalGradient_outPS.ps", "wb") as out_ps_stream:
 6    # Create the save options with the A4 size
 7    options = PsSaveOptions()
 8    
 9    # Create a new 1-paged PS Document
10    document = PsDocument(out_ps_stream, options, False)
11    
12    offset_x = 200.
13    offset_y = 100.
14    width = 200.
15    height = 100.
16    
17    # Create a graphics path from the first rectangle
18    path = aspose.pydrawing.drawing2d.GraphicsPath()
19    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
20    
21    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
22    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
23        aspose.pydrawing.Color.from_argb(150, 0, 0, 0), aspose.pydrawing.Color.from_argb(50, 40, 128, 70), 0)
24    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
25    # Translation components are offsets of the rectangle
26    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
27    # Set the transform
28    brush.transform = brush_transform
29    
30    # Set the paint
31    document.set_paint(brush)
32    
33    # Fill the rectangle
34    document.fill(path)
35    
36    # Fill the text with the gradient
37    font = ExternalFontCache.fetch_dr_font("Arial", 96, aspose.pydrawing.FontStyle.BOLD)
38    document.fill_and_stroke_text("ABC", font, 200, 300, brush,
39    GraphicsFactory.create_pen_by_brush_and_width(aspose.pydrawing.SolidBrush(aspose.pydrawing.Color.black), 2))
40    
41    # Set a current stroke
42    document.set_stroke(GraphicsFactory.create_pen_by_brush_and_width(brush, 5))
43    # Outline text with the gradient
44    document.outline_text("ABC", font, 200, 400)
45    
46    # Close the current page
47    document.close_page()
48    
49    # Save the document
50    document.save()

El resultado de ejecutar este código es

Gradiente horizontal

En este fragmento de código puede ver la creación de un degradado lineal vertical a partir de 5 colores y el relleno de un rectángulo con este degradado.

 1# The path to the documents directory.
 2data_dir = Util.get_data_dir_working_with_gradient()
 3
 4# Create an output stream for the PostScript document
 5with open(data_dir + "VerticalGradient_outPS.ps", "wb") as out_ps_stream:
 6    # Create the save options with the A4 size
 7    options = PsSaveOptions()
 8    
 9    # Create a new 1-paged PS Document
10    document = PsDocument(out_ps_stream, options, False)
11    
12    offset_x = 200.
13    offset_y = 100.
14    width = 200.
15    height = 100.
16    
17    # Create a graphics path from the first rectangle
18    path = aspose.pydrawing.drawing2d.GraphicsPath()
19    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
20    
21    # Create an array of interpolation colors
22    colors = [ aspose.pydrawing.Color.red, aspose.pydrawing.Color.green, aspose.pydrawing.Color.blue,
23    aspose.pydrawing.Color.orange, aspose.pydrawing.Color.dark_olive_green ]
24    positions = [ 0.0, 0.1873, 0.492, 0.734, 1.0 ]
25    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
26    color_blend.colors = colors
27    color_blend.positions = positions
28    
29    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
30    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
31    aspose.pydrawing.Color.beige, aspose.pydrawing.Color.dodger_blue, 0)
32    # Set interpolation colors
33    brush.interpolation_colors = color_blend
34    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
35    # Translation components are offsets of the rectangle
36    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
37    # Rotate transform to get colors change in the vertical direction from up to down
38    brush_transform.rotate(90.)
39    # Set the transform
40    brush.transform = brush_transform
41    
42    # Set the paint
43    document.set_paint(brush)
44    
45    # Fill the rectangle
46    document.fill(path)
47    
48    # Close the current page
49    document.close_page()
50    
51    # Save the document
52    document.save()

Aquí viene el resultado

Gradiente vertical

En este fragmento de código creamos un degradado lineal diagonal a partir de 2 colores y rellenamos un rectángulo con este degradado.

 1# Create an output stream for PostScript document
 2with open(data_dir + "DiagonaGradient_outPS.ps", "wb") as out_ps_stream:
 3    # Create the save options with A4 size
 4    options = PsSaveOptions()
 5    
 6    # Create a new 1-paged PS Document
 7    document = PsDocument(out_ps_stream, options, False)
 8    
 9    offset_x = 200.
10    offset_y = 100.
11    width = 200.
12    height = 100.
13    
14    # Create a graphics path from the first rectangle
15    path = aspose.pydrawing.drawing2d.GraphicsPath()
16    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
17    
18    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
19    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
20    aspose.pydrawing.Color.from_argb(255, 255, 0, 0), aspose.pydrawing.Color.from_argb(255, 0, 0, 255), 0)
21    
22    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
23    # Translation components are offsets of the rectangle                
24    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
25    # Rotate gradient, than scale and translate to get the visible color transition in the required rectangle
26    brush_transform.rotate(-45.)
27    hypotenuse = float(math.sqrt(200. * 200. + 100. * 100.))
28    ratio = hypotenuse / 200.
29    brush_transform.scale(-ratio, 1.)
30    brush_transform.translate(100. / brush_transform.elements[0], 0.)
31    
32    # Set the transform
33    brush.transform = brush_transform
34    
35    # Set the paint
36    document.set_paint(brush)
37    
38    # Fill the rectangle
39    document.fill(path)
40    
41    # Close the current page
42    document.close_page()
43    
44    # Save the document
45    document.save()

Aquí viene el resultado

Degradado diagonal

Aquí creamos un degradado radial a partir de 2 colores y rellenamos un círculo con este degradado.

 1# The path to the documents directory.
 2data_dir = Util.get_data_dir_working_with_gradient()
 3
 4# Create an output stream for the PostScript document
 5with open(data_dir + "RadialGradient1_outPS.ps", "wb") as out_ps_stream:
 6    # Create the save options with A4 size
 7    options = PsSaveOptions()
 8    
 9    # Create a new 1-paged PS Document
10    document = PsDocument(out_ps_stream, options, False)
11    
12    offset_x = 200.
13    offset_y = 100.
14    width = 200.
15    height = 200.
16    
17    # Create a graphics path from the rectangle bounds
18    bounds = aspose.pydrawing.RectangleF(offset_x, offset_y, width, height)
19    path = aspose.pydrawing.drawing2d.GraphicsPath()
20    path.add_ellipse(bounds)
21    
22    # Create and fill a color blend object
23    colors = [ aspose.pydrawing.Color.white, aspose.pydrawing.Color.white, aspose.pydrawing.Color.blue ]
24    positions = [ 0.0, 0.2, 1.0 ]
25    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
26    color_blend.colors = colors
27    color_blend.positions = positions
28    
29    brush_rect = aspose.pydrawing.drawing2d.GraphicsPath()
30    brush_rect.add_rectangle(aspose.pydrawing.RectangleF(0, 0, width, height))
31    
32    # Create a path gradient brush with a rectangle as a bounds
33    brush = GraphicsFactory.create_path_gradient_brush_by_path(brush_rect)
34    # Set the interpolation colors
35    brush.interpolation_colors = color_blend
36    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
37    # Translation components are offsets of the rectangle
38    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
39    # Set the transform
40    brush.transform = brush_transform
41    
42    # Set the paint
43    document.set_paint(brush)
44    
45    # Fill the rectangle
46    document.fill(path)
47    
48    # Close the current page
49    document.close_page()
50    
51    #Save the document
52    document.save()

el resultado

Gradiente radial imag1

En este fragmento de código creamos un degradado radial a partir de 6 colores y rellenamos un rectángulo con este degradado.

 1# The path to the documents directory.
 2  data_dir = Util.get_data_dir_working_with_gradient()
 3  
 4# Create an utput stream for the PostScript document
 5with open(data_dir + "RadialGradient2_outPS.ps", "wb") as out_ps_stream:
 6    # Create save options with the A4 size
 7    options = PsSaveOptions()
 8    
 9    # Create a new 1-paged PS Document
10    document = PsDocument(out_ps_stream, options, False)
11    
12    offset_x = 200.
13    offset_y = 100.
14    width = 200.
15    height = 200.
16    
17    # Create a graphics path from the rectangle bounds
18    bounds = aspose.pydrawing.RectangleF(offset_x, offset_y, width, height)
19    path = aspose.pydrawing.drawing2d.GraphicsPath()
20    path.add_rectangle(bounds)
21    
22    # Create and fill a color blend object
23    colors = [ aspose.pydrawing.Color.green, aspose.pydrawing.Color.blue, aspose.pydrawing.Color.black,
24    aspose.pydrawing.Color.yellow, aspose.pydrawing.Color.beige, aspose.pydrawing.Color.red ]
25    positions = [ 0.0, 0.2, 0.3, 0.4, 0.9, 1.0 ]
26    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
27    color_blend.colors = colors
28    color_blend.positions = positions
29    
30    brush_rect = aspose.pydrawing.drawing2d.GraphicsPath()
31    brush_rect.add_rectangle(aspose.pydrawing.RectangleF(0, 0, width, height))
32    
33    # Create a path gradient brush with a rectangle as a bounds
34    brush = GraphicsFactory.create_path_gradient_brush_by_path(brush_rect)
35    # Set interpolation colors
36    brush.interpolation_colors = color_blend
37    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
38    # Translation components are offsets of the rectangle
39    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
40    # Set the transform
41    brush.transform = brush_transform
42    
43    # Set the paint
44    document.set_paint(brush)
45    
46    # Fill the rectangle
47    document.fill(path)
48    
49    # Close the current page
50    document.close_page()
51    
52    # Save the document
53    document.save()

El resultado se ve de la siguiente manera.

Imagen de degradado radial 2

Consulte cómo trabajar con degradados en documentos PS en .NET, Java.

Puede descargar ejemplos y archivos de datos desde GitHub.

Trabajar con texturas Trabajar con patrones de sombreado

Have any questions about Aspose.Page?



Subscribe to Aspose Product Updates

Get monthly newsletters & offers directly delivered to your mailbox.

© Aspose Pty Ltd 2001-2025. All Rights Reserved.