Working with Hatch Patterns in PS file | Python

Add Hatch Pattern in PS Document

Hatch patterns, often comprising simple black-and-white images with various hatch designs, serve as texture tiling patterns. In Aspose.Page for Python via .NET, these patterns are represented by the aspose.pydrawing.drawing2d.HatchBrush class, derived from aspose.pydrawing.Brush. Unlike aspose.pydrawing.TextureBrush, HatchBrush offers named predefined styles, defining the image used for tiling. Aspose.Page for Python provides 53 hatch styles, all of which can be utilized for filling or stroking in PsDocument.

To paint graphics objects with a hatch pattern, create a HatchBrush with the desired hatch style and pass it into set_paint() or one of the fill_text() or fill_and_stroke_text() methods accepting aspose.pydrawing.Brush.

To outline graphics objects with a hatch pattern, set the hatch pattern as the current paint in PsDocument, create a new aspose.pydrawing.Pen, and pass it to set_stroke() or one of the outline_text() or fill_and_stroke_text() methods accepting aspose.pydrawing.Pen.

The example below demonstrates filling a shape with a hatch pattern, showcasing various hatch styles in Python, and filling and outlining text with a hatch pattern.

Here’s the algorithm for painting graphics objects with a hatch pattern in a new PS document:

1. Create an output stream for the resulting PS file.
2. Initiate PsSaveOptions.
3. Create a PsDocument with the already created output stream and save options.
4. Create the shape or a font in dependence on what object we are going to fill or outline.
5. Create an object of aspose.pydrawing.drawing2d.HatchBrush with the desired style.
6. Set the hatch paint as a current paint in the PsDocument
7. Fill the shape with the current paint or fill the text. If we use one of the methods for filling the text that accepts aspose.pydrawing.Brush as a parameter, the previous step can be skipped.
8. Close the page.
9. Save the document.

If we need stroking (outlining) graphics objects with a hatch pattern instead of the last 4 steps will have the next look:

6. Set the hatch paint as a current paint in PsDocument.
7. Create aspose.pydrawing.Pen object.
8. Set this stroke as current stroke in PsDocument.
9. Outline the shape with the current paint and stroke or outline the text. If we use one of the methods for outlining the text that accepts aspose.pydrawing.Pen as a parameter, previous step can be ignored.
10. Close the page.
11. Save the document.

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

# Create an output stream for the PostScript document
with open(data_dir + "AddHatchPattern_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)
    
    x0 = 20.
    y0 = 100.
    square_side = 32.
    width = 500.
    sum_x = 0.
    
    # Restore a graphics state
    document.write_graphics_save()
    
    # Translate to initial point
    document.translate(x0, y0)
    
    # Create a rectngle path for every pattern square
    path = aspose.pydrawing.drawing2d.GraphicsPath()
    path.add_rectangle(aspose.pydrawing.RectangleF(0, 0, square_side, square_side))
    
    # Create a pen for outlining the pattern square
    pen = GraphicsFactory.create_pen_by_color_and_width(aspose.pydrawing.Color.black, 2)
    
    # For every hatch pattern style 
    hatch_style = 0
    while hatch_style <= 52:
        # Set the paint with the current hatch brush style
        document.set_paint(aspose.pydrawing.drawing2d.HatchBrush(aspose.pydrawing.drawing2d.HatchStyle(hatch_style),
            aspose.pydrawing.Color.black, aspose.pydrawing.Color.white))
        
        # Calculate the displacement not to go beyond the page bounds
        x = square_side
        y = 0
        if sum_x >= width:
            x = -(sum_x - square_side)
            y += square_side
        # Translate the current graphics state
        document.translate(x, y)
        # Fill the pattern square
        document.fill(path)
        # Set the stroke
        document.set_stroke(pen)
        # Draw the square outline
        document.draw(path)
        
        # Calculate the distance from X0
        if sum_x >= width:
            sum_x = square_side
        else:
            sum_x += x
        hatch_style += 1
    
    # Restore the graphics state
    document.write_graphics_restore()
    
    # Fill the text with the hatch pattern
    brush = aspose.pydrawing.drawing2d.HatchBrush(aspose.pydrawing.drawing2d.HatchStyle.DIAGONAL_CROSS,
    aspose.pydrawing.Color.red, aspose.pydrawing.Color.yellow)
    font = ExternalFontCache.fetch_dr_font("Arial", 96, aspose.pydrawing.FontStyle.BOLD)
    document.fill_and_stroke_text("ABC", font, 200, 300, brush, pen)
    
    # Outline text with the hatch pattern
    brush = aspose.pydrawing.drawing2d.HatchBrush(aspose.pydrawing.drawing2d.HatchStyle.PERCENT50,
    aspose.pydrawing.Color.blue, aspose.pydrawing.Color.white)
    document.outline_text("ABC", font, 200, 400, GraphicsFactory.create_pen_by_brush_and_width(brush, 5))
    
    
    # Close the current page
    document.close_page()
    
    # Save the document
    document.save()

See working with a hatch pattern in PS document in .NET, Java.

The result of running this code is

You can download examples and data files from GitHub.