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:

• aspose.pydrawing.drawing2d.LinearGradientBrush
• aspose.pydrawing.drawing2d.PathGradientBrush

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:

8. Impostare il gradiente come colore corrente in PsDocument.
9. Creare l’oggetto aspose.pydrawing.Pen.
10. Impostare questo tratto come tratto corrente in PsDocument.
11. 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.
12. Chiudere la pagina.
13. 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.

# The path to the documents directory.
data_dir = Util.get_data_dir_working_with_gradient()

# Create an output stream for the PostScript document
with open(data_dir + "HorizontalGradient_outPS.ps", "wb") as out_ps_stream:
    # Create the save options with the A4 size
    options = PsSaveOptions()
    
    # Create a new 1-paged PS Document
    document = PsDocument(out_ps_stream, options, False)
    
    offset_x = 200.
    offset_y = 100.
    width = 200.
    height = 100.
    
    # Create a graphics path from the first rectangle
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
    
    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
        aspose.pydrawing.Color.from_argb(150, 0, 0, 0), aspose.pydrawing.Color.from_argb(50, 40, 128, 70), 0)
    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
    # Translation components are offsets of the rectangle
    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
    # Set the transform
    brush.transform = brush_transform
    
    # Set the paint
    document.set_paint(brush)
    
    # Fill the rectangle
    document.fill(path)
    
    # Fill the text with the gradient
    font = ExternalFontCache.fetch_dr_font("Arial", 96, aspose.pydrawing.FontStyle.BOLD)
    document.fill_and_stroke_text("ABC", font, 200, 300, brush,
    GraphicsFactory.create_pen_by_brush_and_width(aspose.pydrawing.SolidBrush(aspose.pydrawing.Color.black), 2))
    
    # Set a current stroke
    document.set_stroke(GraphicsFactory.create_pen_by_brush_and_width(brush, 5))
    # Outline text with the gradient
    document.outline_text("ABC", font, 200, 400)
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

Il risultato dell’esecuzione di questo codice è

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.

# The path to the documents directory.
data_dir = Util.get_data_dir_working_with_gradient()

# Create an output stream for the PostScript document
with open(data_dir + "VerticalGradient_outPS.ps", "wb") as out_ps_stream:
    # Create the save options with the A4 size
    options = PsSaveOptions()
    
    # Create a new 1-paged PS Document
    document = PsDocument(out_ps_stream, options, False)
    
    offset_x = 200.
    offset_y = 100.
    width = 200.
    height = 100.
    
    # Create a graphics path from the first rectangle
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
    
    # Create an array of interpolation colors
    colors = [ aspose.pydrawing.Color.red, aspose.pydrawing.Color.green, aspose.pydrawing.Color.blue,
    aspose.pydrawing.Color.orange, aspose.pydrawing.Color.dark_olive_green ]
    positions = [ 0.0, 0.1873, 0.492, 0.734, 1.0 ]
    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
    color_blend.colors = colors
    color_blend.positions = positions
    
    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
    aspose.pydrawing.Color.beige, aspose.pydrawing.Color.dodger_blue, 0)
    # Set interpolation colors
    brush.interpolation_colors = color_blend
    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
    # Translation components are offsets of the rectangle
    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
    # Rotate transform to get colors change in the vertical direction from up to down
    brush_transform.rotate(90.)
    # Set the transform
    brush.transform = brush_transform
    
    # Set the paint
    document.set_paint(brush)
    
    # Fill the rectangle
    document.fill(path)
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

Ecco il risultato!

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

# Create an output stream for PostScript document
with open(data_dir + "DiagonaGradient_outPS.ps", "wb") as out_ps_stream:
    # Create the save options with A4 size
    options = PsSaveOptions()
    
    # Create a new 1-paged PS Document
    document = PsDocument(out_ps_stream, options, False)
    
    offset_x = 200.
    offset_y = 100.
    width = 200.
    height = 100.
    
    # Create a graphics path from the first rectangle
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(aspose.pydrawing.RectangleF(offset_x, offset_y, width, height))
    
    # Create a linear gradient brush with a rectangle as a bounds, start and end colors
    brush = GraphicsFactory.create_linear_gradient_brush_by_rect_and_angle(aspose.pydrawing.RectangleF(0, 0, width, height),
    aspose.pydrawing.Color.from_argb(255, 255, 0, 0), aspose.pydrawing.Color.from_argb(255, 0, 0, 255), 0)
    
    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
    # Translation components are offsets of the rectangle                
    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
    # Rotate gradient, than scale and translate to get the visible color transition in the required rectangle
    brush_transform.rotate(-45.)
    hypotenuse = float(math.sqrt(200. * 200. + 100. * 100.))
    ratio = hypotenuse / 200.
    brush_transform.scale(-ratio, 1.)
    brush_transform.translate(100. / brush_transform.elements[0], 0.)
    
    # Set the transform
    brush.transform = brush_transform
    
    # Set the paint
    document.set_paint(brush)
    
    # Fill the rectangle
    document.fill(path)
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

Ecco il risultato!

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

# The path to the documents directory.
data_dir = Util.get_data_dir_working_with_gradient()

# Create an output stream for the PostScript document
with open(data_dir + "RadialGradient1_outPS.ps", "wb") as out_ps_stream:
    # Create the save options with A4 size
    options = PsSaveOptions()
    
    # Create a new 1-paged PS Document
    document = PsDocument(out_ps_stream, options, False)
    
    offset_x = 200.
    offset_y = 100.
    width = 200.
    height = 200.
    
    # Create a graphics path from the rectangle bounds
    bounds = aspose.pydrawing.RectangleF(offset_x, offset_y, width, height)
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_ellipse(bounds)
    
    # Create and fill a color blend object
    colors = [ aspose.pydrawing.Color.white, aspose.pydrawing.Color.white, aspose.pydrawing.Color.blue ]
    positions = [ 0.0, 0.2, 1.0 ]
    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
    color_blend.colors = colors
    color_blend.positions = positions
    
    brush_rect = aspose.pydrawing.drawing2d.GraphicsPath()
    brush_rect.add_rectangle(aspose.pydrawing.RectangleF(0, 0, width, height))
    
    # Create a path gradient brush with a rectangle as a bounds
    brush = GraphicsFactory.create_path_gradient_brush_by_path(brush_rect)
    # Set the interpolation colors
    brush.interpolation_colors = color_blend
    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
    # Translation components are offsets of the rectangle
    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
    # Set the transform
    brush.transform = brush_transform
    
    # Set the paint
    document.set_paint(brush)
    
    # Fill the rectangle
    document.fill(path)
    
    # Close the current page
    document.close_page()
    
    #Save the document
    document.save()

Il risultato

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

# The path to the documents directory.
  data_dir = Util.get_data_dir_working_with_gradient()
  
# Create an utput stream for the PostScript document
with open(data_dir + "RadialGradient2_outPS.ps", "wb") as out_ps_stream:
    # Create save options with the A4 size
    options = PsSaveOptions()
    
    # Create a new 1-paged PS Document
    document = PsDocument(out_ps_stream, options, False)
    
    offset_x = 200.
    offset_y = 100.
    width = 200.
    height = 200.
    
    # Create a graphics path from the rectangle bounds
    bounds = aspose.pydrawing.RectangleF(offset_x, offset_y, width, height)
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(bounds)
    
    # Create and fill a color blend object
    colors = [ aspose.pydrawing.Color.green, aspose.pydrawing.Color.blue, aspose.pydrawing.Color.black,
    aspose.pydrawing.Color.yellow, aspose.pydrawing.Color.beige, aspose.pydrawing.Color.red ]
    positions = [ 0.0, 0.2, 0.3, 0.4, 0.9, 1.0 ]
    color_blend = aspose.pydrawing.drawing2d.ColorBlend()
    color_blend.colors = colors
    color_blend.positions = positions
    
    brush_rect = aspose.pydrawing.drawing2d.GraphicsPath()
    brush_rect.add_rectangle(aspose.pydrawing.RectangleF(0, 0, width, height))
    
    # Create a path gradient brush with a rectangle as a bounds
    brush = GraphicsFactory.create_path_gradient_brush_by_path(brush_rect)
    # Set interpolation colors
    brush.interpolation_colors = color_blend
    # Create a transform for brush. X and Y scale component must be equal to the width and height of the rectangle correspondingly.
    # Translation components are offsets of the rectangle
    brush_transform = aspose.pydrawing.drawing2d.Matrix(width, 0., 0., height, offset_x, offset_y)
    # Set the transform
    brush.transform = brush_transform
    
    # Set the paint
    document.set_paint(brush)
    
    # Fill the rectangle
    document.fill(path)
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

TIl risultato appare come segue

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

È possibile scaricare esempi e file di dati da GitHub.