How to draw repeated slanted lines

Question

I need to draw slanted lines like this programmatically using opencv-python, and it has to be similar in terms of the slant angle and the distance between the lines:

If using OpenCV cv.line() i need to supply the function with the line's start and endpoint.
Following this StackOverflow accepted answer, I think I will be able to know those two points, but first I need to calculate the line equation itself.

So what I have done is first I calculate the slant angle of the line using the measure tool in ai (The actual image was given by the graphic designer as ai (adobe illustrator) file), and I got 67deg and I solve the gradient of the line. But the problem is I don't know how to get the horizontal spacing/distance between the lines. I needed that so i can supply the start.X. I used the illustrator, and try to measure the distance between the lines but how to map it to opencv coordinate?

Overall is my idea feasible? Or is there a better way to achieve this?

Update 1: I managed to draw this experimental image:

And this is code:

def show_image_scaled(window_name,image,height,width):
    cv2.namedWindow(window_name,cv2.WINDOW_NORMAL)
    cv2.resizeWindow(window_name,width,height)
    cv2.imshow(window_name,image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def slanted_lines_background():
    canvas = np.ones((200,300)) * 255
    end_x = 0
    start_y = 0
    m = 2.35
    end_x = 0
    for x in range(0,canvas.shape[1],10):
        start_x = x
        end_y = start_y + compute_length(m,start_x,start_y,end_x)
        cv2.line(canvas,(start_x,start_y),(end_x,end_y),(0,0,0),2)

    show_image_scaled("Slant",canvas,200,300)

def compute_length(m,start_x,start_y,end_x=0):
    c = start_y - (m * start_x)
    length_square = (end_x - start_x)**2 + ((m *end_x) + c - start_y) ** 2
    length = math.sqrt(length_square)
    return int(length)

Still working on to fill the left part of the rectangle

Answer 1

This code "shades" every pixel in a given image to produce your hatched pattern. Don't worry about the math. It's mostly correct. I've checked the edge cases for small and wide lines. The sampling isn't exactly correct but nobody's gonna notice anyway because the imperfection amounts to small fractions of a pixel. And I've used numba to make it fast.

import numpy as np
from numba import njit, prange

@njit(parallel=True)
def hatch(im, angle=45, stride=10, dc=None):
    stride = float(stride)
    if dc is None:
        dc = stride * 0.5

    assert 0 <= dc <= stride

    stride2 = stride / 2
    dc2 = dc / 2
    angle = angle / 180 * np.pi
    c = np.cos(angle)
    s = np.sin(angle)

    (height, width) = im.shape[:2]
    for y in prange(height):
        for x in range(width):
            # distance to origin along normal
            dist_origin = c*x - s*y
            
            # distance to center of nearest line
            dist_center = stride2 - abs((dist_origin % stride) - stride2)
            
            # distance to edge of nearest line
            dist_edge = dist_center - dc2
            
            # shade pixel, with antialiasing
            # use edge-0.5 to edge+0.5 as "gradient" <=> 1-sized pixel straddles edge
            # for thick/thin lines, needs hairline handling
            # thin line -> gradient hits far edge of line / pixel may span both edges of line
            # thick line -> gradient hits edge of adjacent line / pixel may span adjacent line
  
            if dist_edge > 0.5: # background
                val = 0

            else: # pixel starts covering line
                val = 0.5 - dist_edge

                if dc < 1: # thin line, clipped to line width
                    val = min(val, dc)

                elif stride - dc < 1: # thick line, little background
                    val = max(val, 1 - (stride - dc))

            im[y,x] = val

canvas = np.zeros((128, 512), 'f4')
hatch(canvas, angle=-23, stride=5, dc=2.5)

# mind the gamma mapping before imshow