Arbeiten mit Farbverlauf in PS-Datei | Python

Fügen Sie einen Farbverlauf im PS-Dokument hinzu

In diesem Artikel wird die Implementierung von Farbverläufen in PS-Dokumenten mit Aspose.Page für Python untersucht.

Farbverläufe stellen einen sanften Übergang zwischen den Farben dar und erhöhen den Realismus gezeichneter Bilder.

In Aspose.Page für Python werden Farbverläufe als Unterklassen von aspose.pydrawing.Brush implementiert, nämlich:

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

Um Farbe oder Strich in einem PsDocument anzuwenden, werden Objekte der Klasse aspose.pydrawing.Brush zum Malen und aspose.pydrawing.Pen zum Streichen an die entsprechenden Methoden übergeben. Aspose.Page für Python unterstützt alle wesentlichen Klassen innerhalb von aspose.pydrawing.Brush, die von der .NET-Plattform angeboten werden, einschließlich aspose.pydrawing.Color, aspose.pydrawing.TextureBrush, aspose.pydrawing.drawing2d .LinearGradientBrush und aspose.pydrawing.drawing2d.PathGradientBrush. Die Strichfarbe wird separat von den Stricheigenschaften mithilfe von aspose.pydrawing.Brush im aspose.pydrawing.Pen-Objekt zugewiesen.

Um Grafikobjekte mit einem Farbverlauf zu malen, erstellen Sie entweder aspose.pydrawing.drawing2d.LinearGradientBrush oder aspose.pydrawing.drawing2d.PathGradientBrush und übergeben Sie es an set_paint() oder eines der Methoden fill_text() oder fill_and_Stroke_text(), die aspose.pydrawing.Brush als Parameter akzeptieren.

Um Grafikobjekte mit einem Farbverlauf zu umreißen, übergeben Sie entweder aspose.pydrawing.drawing2d.LinearGradientBrush oder aspose.pydrawing.drawing2d.PathGradientBrush an set_paint() oder einen der * *outline_text()**- oder fill_and_Stroke_text()-Methoden, die Strichfarbe als Parameter akzeptieren.

Im folgenden Beispiel zeigen wir, wie man eine Form und einen Text füllt und den Text mit einem Farbverlauf umrandet.

Ein Algorithmus zum Malen von Grafikobjekten mit einem Farbverlauf in einem neuen PS-Dokument umfasst die folgenden Schritte:

1. Erstellen Sie einen Ausgabestream für die resultierende PS-Datei.
2. Initiieren Sie PsSaveOptions.
3. Erstellen Sie ein PsDocument mit dem bereits erstellten Ausgabestream und den Speicheroptionen.
4. Erstellen Sie den erforderlichen Grafikpfad oder eine Schriftart, abhängig davon, welches Objekt wir füllen oder umreißen möchten.
5. Erstellen Sie ein Objekt von aspose.pydrawing.drawing2d.LinearGradientBrush oder aspose.pydrawing.drawing2d.PathGradientBrush in Abhängigkeit von der gewünschten Form eines Farbverlaufs.
6. Stellen Sie an diesem Pinsel die erforderliche Transformation ein.
7. Legen Sie den Verlaufspinsel als aktuelle Farbe im PsDocument fest
8. Füllen Sie den Grafikpfad mit der aktuellen Farbe oder füllen Sie den Text. Wenn wir eine der Methoden zum Füllen des Textes verwenden, die aspose.pydrawing.Brush als Parameter akzeptiert, kann der vorherige Schritt ignoriert werden.
9. Schließen Sie die Seite.
10. Speichern Sie das Dokument.

Wenn wir Grafikobjekte mit einem Farbverlauf streichen (umreißen) müssen, sehen die letzten 4 Schritte wie folgt aus: 8. Legen Sie den Farbverlauf als aktuelle Farbe in PsDocument fest. 9. Erstellen Sie das Objekt aspose.pydrawing.Pen. 10. Legen Sie diesen Strich als aktuellen Strich in PsDocument fest. 11. Umreißen Sie den Grafikpfad mit dem aktuellen Strich oder umreißen Sie den Text. Wenn wir eine der Methoden zum Umreißen des Textes verwenden, die aspose.pydrawing.Pen als Parameter akzeptiert, kann der vorherige Punkt ignoriert werden. 12. Schließen Sie die Seite. 13. Speichern Sie das Dokument.

Hier sind 5 separate Codeausschnitte, die die Verwendung verschiedener Farbverläufe demonstrieren. In diesem Fall erstellen wir einen horizontalen linearen Farbverlauf aus zwei Farben, füllen ein Rechteck, füllen einen Text und umreißen einen Text mit diesem Farbverlauf.

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

Das Ergebnis der Ausführung dieses Codes ist

In diesem Codeausschnitt können Sie die Erstellung eines vertikalen linearen Farbverlaufs aus 5 Farben und das Füllen eines Rechtecks ​​mit diesem Farbverlauf sehen.

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

Hier kommt das Ergebnis

In diesem Codeausschnitt erstellen wir einen diagonalen linearen Farbverlauf aus 2 Farben und füllen ein Rechteck mit diesem Farbverlauf.

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

Hier kommt das Ergebnis

Hier erstellen wir einen radialen Farbverlauf aus 2 Farben und füllen einen Kreis mit diesem Farbverlauf.

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

Das Ergebnis

In diesem Codeausschnitt erstellen wir einen radialen Farbverlauf aus 6 Farben und füllen ein Rechteck mit diesem Farbverlauf.

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

Das Ergebnis sieht wie folgt aus

Weitere Informationen finden Sie unter „Arbeiten mit Farbverläufen in PS-Dokumenten“ in .NET, Java.

Sie können Beispiele und Datendateien herunterladen von GitHub.