saving image in linux fails

[phitaylr]

The code below works fine on Windows, which allows me to preview in low resolution using a py5 window and generate higher resolution frames using multiprocessing for the final output. However, no frames are saved using make_image in linux.

img.save() doesn't produce any error messages, it just doesn't actually save a frame. I get a numpy runtime warning using both, but draw method still works. save_frame() works as expeced in draw, but that doesn't help with multiprocessing.

Has anyone ran into something similar?

def make_image(i): 
    img = py5.create_image_from_numpy(julia(1024, 1024, x=x, y=y, zoom=zooms[i]), 'RGB')
    img.save('vids/julia/{i:06d}.png')
    print(i)

def draw():
    global  i
    img = py5.create_image_from_numpy(julia(py5.width, py5.height, x=x, y=y, zoom=zooms[i]), 'RGB')
    py5.image(img, 0, 0)
    i+=1

[hx2A]

Hello, @phitaylr !

When you say multiprocessing, are you referring to Python's multiprocessing library? Can you explain more about what you are doing? I've never used that with py5 and I suspect there might be some hidden pitfalls. I do know that Python's multiprocessing library works very differently on Windows because Windows OS doesn't support forking like linux does. Is your julia() function using multiprocessing?

Also, you might have a typo in make_image(i). Did you mean to type img.save(f'vids/julia/{i:06d}.png')?

In any case, I think you'd get better performance in make_image(i) if you used PIL Images instead of py5's Py5Image objects. For example:

from PIL import Image

def make_image(i):
    img = Image.fromarray(julia(1024, 1024, x=x, y=y, zoom=zooms[i]), mode='RGB')
    img.save(f'vids/julia/{i:06d}.png')
    print(i)

When py5 saves an image or frame it is actually using PIL, not Processing's save functionality. PIL can save in more formats and has more extensive functionality. Creating Py5Image objects and then saving them right away is going to be slower because you are creating unneeded Java objects. Better to go PIL Images directly.

[phitaylr]

That did the trick! Thank you so much for your help, @hx2A ! This makes for a powerful combination for creating frames for a video at higher resolution and previewing in a py5 window at lower resolution.

Yes, I was referring to python's multiprocessing library. Using PIL directly did speed things up. My julia() function creates one frame of a julia set at a given zoom level. They are generated with

frames = range(3000)
pool=Pool(processes=12)
pool.map(make_image, frames)

I'm still learning a lot about numpy. Right now, when a point diverges and is not in the julia set, it's last value (in sols) is numpy.nan after an overflow. Image.fromarray() turns that to black. My next goal is to map those nan values to white. It might also be faster if there was a way to break execution for the pixels after they reach some maximum value instead of going to maxits for all of them.

Anyway, thanks again so much for your input and all your work on the project! I'm having so much fun exploring py5.

def julia(height, width, x=-0.5, y=0, zoom=1,):
    x_width = 1.5
    y_height = 1.5*height/width
    x_from = x - x_width/zoom
    x_to = x + x_width/zoom
    y_from = y - y_height/zoom
    y_to = y + y_height/zoom
    # print(x_from, x_to, y_from, y_to)
    x = np.linspace(x_from, x_to, num=width).reshape((1, width))
    y = np.linspace(y_from, y_to, num=height).reshape((height, 1))
    c = x + 1j * y
    for _ in range(min(maxits, 200)):
        sols = c*c + (0.355 + 0.355j)
        c = sols  
    sols = sols.round(3)
    return np.dstack(np.broadcast_arrays(10,py5.remap(abs(sols.imag), 0, 1, 20, 255), py5.remap(abs(sols.real), 0, 1, 20, 255))).astype(np.uint8)

[hx2A]

OK, now I understand what you were using multiprocessing for. In your first code example, multprocessing was calling make_image() and that function was making a call to py5.create_image_from_numpy(). I would not expect that to work correctly because you should not call py5 functions outside of an actual running Sketch. It seems like it did work for you on Windows but that was probably a fluke because of the differences in how multiprocessing works on that OS. In any case, I'm glad you now have it working in a way that makes you happy.

Right now, when a point diverges and is not in the julia set, it's last value (in sols) is numpy.nan after an overflow.

Try using np.isnan() and np.where() to change the nan values to something else.

Anyway, thanks again so much for your input and all your work on the project! I'm having so much fun exploring py5.

You are very welcome! Happy exploring!

[phitaylr]

Thanks again for help, here was the final result: https://www.instagram.com/p/CpGu55kJVyJ/
I suppose I could have done it all with numpy and PIL, but py5 does make it nice to be able to easily preview.

[hx2A]

Thanks again for help, here was the final result: https://www.instagram.com/p/CpGu55kJVyJ/

You are welcome. The results look great! Thanks for using the #py5 tag!

I suppose I could have done it all with numpy and PIL, but py5 does make it nice to be able to easily preview.

That's fine. Lots of time I use py5 to prototype an idea or think something through. Once I have a good idea of what I want, sometimes I'll use Processing or something else instead. py5 is great for prototyping.