image convolutions help (image processing) without numpy

Question

I need to write function that convolving an image with a kernel.

In other words -The function receives an image with a single color channel (ie a two-dimensional list(for example - [[1,1,1],[1,1,1],[1,1,1]]) and a kernel (also a two-dimensional list), and returns an image of the same size as the original image, with each pixel in the new image calculated by running the kernel on it.

That is: identify the pixel [image [row] [column with the main input in the kernel matrix, and sum the values ​​of its neighbors (including The pixel itself) double the corresponding input for them in the kernel.

When calculating a value for an x-pixel that is on the image boundaries, pixel values ​​that are outside the image boundaries should be considered. The source seemed to have the same value as the pixel x.

For example- for input:

image = [[0,128,255]]

kernel =[[1/9 ,1/9 ,1/9],[1/9 ,1/9 ,1/9] ,[1/9 ,1/9 ,1/9]]

output: [[14,128,241]]

The function starts at about zero and will place it in the center of a kernel-sized matrix, along with the adjacent values ​​that are within the boundaries of this matrix.

In the example, this is a 3 * 3 matrix and therefore the matrix we will receive after entering the values ​​is-[[0,0,0],[0,128,0],[0,0,0]].

After we have entered the corresponding values ​​we will multiply the enter matrix by the kernel matrix (respectively so that pixels in the same coordinates between the two matrices will be multiplied by each other) and sum it all together then enter the result in the image size list instead of the value 0. And then do the same with the next value- 128 and so on.

Eventually, we will return a new image with the new pixels we calculated as I presented.

Another explanation- https://towardsdatascience.com/types-of-convolution-kernels-simplified-f040cb307c37

According to the instructions I received I can not use a numpy.

def new_image(image,kernel):

    new_image= copy.deepcopy(image)

    rows = len(image)
    columns = len(image[0])
    kernel_h = len(kernel)
    kernel_w = len(kernel[0])


    for i in range(rows):
        for j in range(columns):
            sum = 0
            h = (-1 * (kernel_h // 2))
            w = (-1 * (kernel_w // 2))
            for m in range(kernel_h):
                for n in range(kernel_w):

                    if 0 <= j+w < columns:
                            sum += round(kernel[m][n] * new_image[i][j+h])
                    if j + h < 0 or j + h >= columns:
                            sum += round(kernel[m][n] * new_image[i][j])
                    h+=1
                    w+=1

            new_image[i][j] = sum
    return new_image

This is what I wrote until now, but it does not work as required, meaning it does not return the image as required.

Output-[[42, 131, 239]] instead of- [[14,128,241]]

Input=[[0,128,255]

I have no idea how to fix it, i would appreciate help.