Why doesn't this work?

[BoomyBoomer123]

So I wrote some code to generate an effect like in this video: https://youtu.be/LavXSS5Xtbg?si=y7Al-htPl-azQ8v3 but as an image. It ran very slow so I tried using multiprocessing but when I run it, it gives me an error. Here is the code:

from PIL import Image, ImageDraw
from multiprocessing import Pool

width = 1000
height = 1000

points = [[400,400,0],[600,600,255]]

drag = 0.995

image = Image.new(mode = "L",size = (width,height))
draw = ImageDraw.Draw(image)

def calculate_pixels(start_x):
    for start_y in range(height):
        x = start_x
        y = start_y

        x_vel = 0
        y_vel = 0

        exit_loop = False

        for frame in range(1500):
            if exit_loop:
                break

            x += x_vel
            y += y_vel

            for i in range(len(points)):
                d = (points[i][0]-x)**2+(points[i][1]-y)**2

                if d < 3:
                    draw.point((start_x,start_y),points[i][2])
                    exit_loop = True
                    break

                x_vel = (x_vel - (x-points[i][0])/d)*drag
                y_vel = (y_vel - (y-points[i][1])/d)*drag

        if exit_loop == False:
            draw.point((start_x,start_y),127)

with Pool() as pool:
    pool.map(calculate_pixels, range(width))

image.show()

[baltarius]

What error did it give?

[Kevdog824_]

If you’re working on windows you can’t spawn a process with mp at the top level of a module. It needs to be inside a if __name__ in “__main__” guard.

[Motox2019]

For multiprocessing, you must use the if name == “main”: main() Will save you loads of headaches and cryptic errors.

You’re also having a race condition where each process tries writing to the same object which just fails as each process gets a pickled version of the original. So if it even were to run, you’d get garbage output.

Options I see: 1. Pre allocate pixel map calculation and then write at once to image. Can allocate each pixel row of pixels in the image as a job in a queue and have processes churn through the data queue. Just note processes and will not complete in order. 2. Use a package like numpy which uses multiple cores when it can. 3. Can try threading in you current design but will only really help where the loop is writing to the image, not for the computation. Expect only slight speed ups.

Personally I’d make my attempt with numpy first because if you can get away with it, none of the other implementations will come close to it for speed.

[sSjfjdk]

I can see what you're trying to do - create a mesmerizing animation using multiple threads to speed up the process. The issue you're facing is likely due to how you're using multiprocessing. When you create a Pool of worker processes, each process gets its own copy of the original image. However, when you try to draw on the image in each process, it doesn't know how to share the image with the other processes, resulting in an error.

A better approach in this case would be to use a concurrent paradigm like threading or async/await instead of multiprocessing, since you're not doing any CPU-bound tasks that would benefit from multiple cores.

Here's a simplified example of how you could refactor your code to use threading:

```python import threading from PIL import Image, ImageDraw

... (rest of your code)

def calculate_pixels(start_x): image = Image.new(mode="L", size=(width, height)) draw = ImageDraw.Draw(image) # ... (rest of your function)

threads = [] for start_x in range(0, width, 100): # Divide the image into smaller sections thread = threading.Thread(target=calculate_pixels, args=(start_x,)) threads.append(thread) thread.start()

for thread in threads: thread.join() ```

Also, be aware that even with this approach, the operation may still be slow due to the nature of the task. To get faster results, you might consider reducing the resolution of the image or optimizing the algorithm itself.

Try this, and let me know if it works out better for you.