Lavorare con il gradiente in un file PS | Python

Aggiungere una sfumatura in un documento PS

Questo articolo esplora l’implementazione delle sfumature nei documenti PS utilizzando Aspose.Page per Python.

Le sfumature rappresentano una transizione graduale tra i colori, migliorando il realismo delle immagini disegnate.

In Aspose.Page per Python, le sfumature sono implementate come sottoclassi di aspose.pydrawing.Brush, ovvero:

Per applicare pittura o tratto in un PsDocument, gli oggetti della classe aspose.pydrawing.Brush per la pittura e aspose.pydrawing.Pen per il tratto vengono passati ai rispettivi metodi. Aspose.Page per Python supporta tutte le classi essenziali di aspose.pydrawing.Brush offerte dalla piattaforma .NET, tra cui aspose.pydrawing.Color, aspose.pydrawing.TextureBrush, aspose.pydrawing.drawing2d.LinearGradientBrush e aspose.pydrawing.drawing2d.PathGradientBrush. Il colore del tratto viene assegnato separatamente dalle proprietà del tratto utilizzando aspose.pydrawing.Brush nell’oggetto aspose.pydrawing.Pen.

Per colorare oggetti grafici con un gradiente, creare aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush e passarlo a set_paint() o a uno dei metodi fill_text() o fill_and_stroke_text(), che accettano aspose.pydrawing.Brush come parametro.

Per delineare oggetti grafici con un gradiente, passare aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush a set_paint() o a uno dei metodi outline_text() o fill_and_stroke_text(), che accettano il colore del tratto come parametro.

Nell’esempio seguente mostriamo come riempire una forma e un testo e delineare il testo con un gradiente.

Un algoritmo per dipingere oggetti grafici con un gradiente in un nuovo documento PS include i seguenti passaggi:

  1. Creare un flusso di output per il file PS risultante.
  2. Avviare un’operazione PsSaveOptions. 3. Creare un PsDocument con il flusso di output già creato e le opzioni di salvataggio.
  3. Creare il percorso grafico necessario o un font a seconda dell’oggetto che si desidera riempire o delineare.
  4. Creare un oggetto di tipo aspose.pydrawing.drawing2d.LinearGradientBrush o aspose.pydrawing.drawing2d.PathGradientBrush a seconda della forma desiderata del gradiente.
  5. Impostare la trasformazione necessaria su questo pennello.
  6. Impostare il pennello del gradiente come pennello corrente nel PsDocument.
  7. Riempire il percorso grafico con il pennello corrente o riempire il testo. Se si utilizza uno dei metodi per riempire il testo che accetta aspose.pydrawing.Brush come parametro, il passaggio precedente può essere ignorato.
  8. Chiudere la pagina. 10. Salvare il documento.

Se dovessimo contornare (contornare) oggetti grafici con un gradiente, gli ultimi 4 passaggi appariranno come segue:

  1. Impostare il gradiente come colore corrente in PsDocument.
  2. Creare l’oggetto aspose.pydrawing.Pen.
  3. Impostare questo tratto come tratto corrente in PsDocument.
  4. Contornare il percorso grafico con il tratto corrente o il testo. Se utilizziamo uno dei metodi per il contorno del testo che accetta aspose.pydrawing.Pen come parametro, il punto precedente può essere ignorato.
  5. Chiudere la pagina.
  6. Salvare il documento.

Ecco 5 frammenti di codice separati che illustrano l’utilizzo di diversi gradienti.

In questo esempio creiamo un gradiente lineare orizzontale da due colori, riempiamo un rettangolo, riempiamo un testo e contorniamo un testo con questo gradiente.

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

Il risultato dell’esecuzione di questo codice è

Gradiente orizzontale

In questo frammento di codice puoi vedere la creazione di un gradiente lineare verticale a partire da 5 colori e il riempimento di un rettangolo con questo gradiente.

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

Ecco il risultato!

Gradiente Verticale

In questo frammento di codice creiamo un gradiente lineare diagonale da 2 colori e riempiamo un rettangolo con questo gradiente.

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

Ecco il risultato!

Gradiente diagonale

Qui creiamo un gradiente radiale da 2 colori e riempiamo un cerchio con questo gradiente.

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

Il risultato

Radial Gradient imag1

In questo frammento di codice creiamo un gradiente radiale da 6 colori e riempiamo un rettangolo con questo gradiente.

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

TIl risultato appare come segue

Immagine 2 del gradiente radiale

Vedi come lavorare con il gradiente nei documenti PS in .NET, Java.

È possibile scaricare esempi e file di dati da GitHub.

Have any questions about Aspose.Page?



Subscribe to Aspose Product Updates

Get monthly newsletters & offers directly delivered to your mailbox.