Working with Textures in PS file | Python

Add Texture Tiling Pattern in PS Document

A texture tiling pattern refers to an image utilized for filling or drawing objects such as shapes or text. When the image’s size is smaller than that of the object, it’s repeated in both the X and Y directions to cover the required areas adequately.

This repetition of the image within graphics objects is known as tiling. To set paint or stroke in a PsDocument it’s necessary to provide an object of the aspose.pydrawing.Brush class for painting and an object of the aspose.pydrawing.Pen class for stroking in their respective methods.

Aspose.Page for Python via .NET library processes all important classes implemented by aspose.pydrawing.Brush that is offered by the Python platform. These are aspose.pydrawing.Color, aspose.pydrawing.TextureBrush, aspose.pydrawing.drawing2d.LinearGradientBrush, and aspose.pydrawing.drawing2d.PathGradientBrush. A stroke color in Python is assigned separately from the stroke properties in aspose.pydrawing.Pen object with using again aspose.pydrawing.Brush. Thus, Aspose.Page for Python via .NET library can also use a complete set of paint’s implementations for drawing lines and outlining shapes and text.

In order to paint graphics objects with a textured pattern in Aspose.Page for Python via .NET library it is enough to simply pass aspose.pydrawing.TextureBrush into set_paint() or one of the fill_text() or fill_and_stroke_text() methods that accept aspose.pydrawing.Brush as a parameter.

In order to outline graphics objects with a textured pattern you should pass aspose.pydrawing.TextureBrush object also into set_paint() or one of the outline_text() or fill_and_stroke_text() methods that accept stroke paint as a parameter.

In the example below we demonstrate how to fill a shape and a text and outline a text with a texture tiling pattern.

Here is a description of steps of working with Texture Pattern and PsDocument:

1. Create an output stream for the resulting PS file.
2. Initiate a PsSaveOptions object with the default options.
3. Create a 1-paged PsDocument with an already created output stream and save options.
4. Create a new graphics state and translate it to the necessary position.
5. Create aspose.pydrawing.Bitmap from an image file.
6. Create aspose.pydrawing.TextureBrush from the image.
7. Set the necessary transformation in the texture brush.
8. Set the texture paint as a current paint in the current graphics state of the PsDocument.
9. Create a rectangle path.
10. Fill the rectangle with the texture paint.
11. Save the current paint as a local variable for the future use.
12. Set the current paint with a red color.
13. Set a stroke with the 2-point width aspose.pydrawing.Pen
14. Outline the rectangle with the current stroke.
15. Exit from the current graphics state to the upper-level graphics state.
16. Create system font.
17. Fill and stroke (outline) text. For filling the texture paint is used, and for stroking black pen is used.
18. Outline the text in the other position with the texture paint and a new aspose.pydrawing.Pen.
19. Close the page.
20. Save the document.

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

# Create an output stream for the PostScript document
with open(data_dir + "AddTextureTilingPattern_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)
    
    
    document.write_graphics_save()
    document.translate(200, 100)
    
    #Create a Bitmap object from an image file
    with aspose.pydrawing.Bitmap(data_dir + "TestTexture.bmp") as image:
        # Create a texture brush from the image
        brush = aspose.pydrawing.TextureBrush(image, aspose.pydrawing.drawing2d.WrapMode.TILE)
        
        # Add scaling in the X direction to the mattern
        transform = aspose.pydrawing.drawing2d.Matrix(float(2), float(0), float(0), float(1), float(0), float(0))
        brush.transform = transform
        
        # Set this texture brush as a current paint
        document.set_paint(brush)
    
    # Create a rectangle path
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(aspose.pydrawing.RectangleF(0, 0, 200, 100))
    
    # Fill the rectangle
    document.fill(path)
    
    # Get the current paint
    paint = document.get_paint()
    
    # Set a red stroke
    pen1 = aspose.pydrawing.Pen(aspose.pydrawing.Color.red)
    pen1.width = float(2)
    document.set_stroke(pen1)

    # Stroke the rectangle
    document.draw(path)
    
    document.write_graphics_restore()
    
    # Fill the text with the texture pattern                
    font = aspose.page.ExternalFontCache.create_font_by_family_name("Arial", 96, aspose.pydrawing.FontStyle.BOLD)
    pen2 = aspose.pydrawing.Pen(aspose.pydrawing.Color.black)
    pen2.width = float(2)
    document.fill_and_stroke_text("ABC", font, 200, 300, paint, pen2)
    
    # Outline the text with the texture pattern
    pen3 = aspose.pydrawing.Pen(aspose.pydrawing.Color.black)
    pen3.brush = paint
    pen3.width = float(5)
    document.outline_text("ABC", font, 200, 400, pen3)
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

See working with textures in PS documents in .NET, Java.

The result of running this code is

You can download examples and data files from GitHub.