import numpy as np import os import time from PIL import Image from moviepy.editor…
- User
import numpy as np import os import time from PIL import Image from moviepy.editor import VideoClip, ImageSequenceClip from moviepy.video.fx.all import fadein, fadeout from tqdm import tqdm from multiprocessing import Pool from functools import partial
Paths
image_one_path = '/home/daddy/morph/one.jpeg' image_two_path = '/home/daddy/morph/two.jpeg' output_path = '/home/daddy/morph/output' output_filename = f'tornado_morph{int(time.time())}.mp4'
Function to create each frame of the video
def make_frame(t, img1_array, img2_array, particle_positions, explosion_offsets, duration1, duration2, duration3, width, height, particle_size, total_duration): if t < duration1: # Display the first image frame_array = img1_array.copy() elif t < duration1 + duration2: # Morphing effect with particle explosion and movement to tornado progress = (t - duration1) / duration2 # Normalize progress to [0, 1]
# Create an empty frame with transparency frame_array = img1_array.copy() for idx, (x, y) in enumerate(particle_positions): # Explosion offsets offset_x, offset_y = explosion_offsets[idx] if progress < 0.3: # Explosion phase explosion_progress = progress / 0.3 # Scale progress to [0, 1] current_x = x + explosion_progress * offset_x current_y = y + explosion_progress * offset_y else: # Movement towards tornado tornado_progress = (progress - 0.3) / 0.7 # Scale progress to [0, 1] # Calculate tornado position at current time tornado_x = width * tornado_progress tornado_y = height / 2 + (height / 4) * np.sin(2 * np.pi * tornado_progress * 3) # Sine wave path # Current position moves towards tornado position current_x = x + tornado_progress * (tornado_x - x) current_y = y + tornado_progress * (tornado_y - y) # Convert positions to integers and ensure they stay within frame boundaries current_x = int(np.clip(current_x, 0, width - particle_size)) current_y = int(np.clip(current_y, 0, height - particle_size)) # Extract patch from the first image patch = img1_array[y:y + particle_size, x:x + particle_size].copy() # Place the current patch onto the frame frame_array[current_y:current_y + particle_size, current_x:current_x + particle_size] = patch else: # Reveal second image as tornado moves across the screen # Create a mask based on tornado position progress = (t - duration1 - duration2) / duration3 # Normalize progress to [0, 1] # Calculate tornado position at current time tornado_x = width * progress tornado_radius = width / 10 # Adjust as needed # Create a circular mask centered on tornado position y_indices, x_indices = np.ogrid[:height, :width] mask = ((x_indices - tornado_x) ** 2 + (y_indices - height / 2) ** 2) <= (tornado_radius ** 2) # Initialize frame with the first image frame_array = img1_array.copy() # Replace pixels within the mask with pixels from the second image frame_array[mask] = img2_array[mask] # Convert the NumPy array back to an image frame_image = Image.fromarray(frame_array, 'RGBA') # Return frame as an RGB image (MoviePy expects RGB format) return np.array(frame_image.convert('RGB'))Function for processing a range of frames (used in multiprocessing)
def process_frame_range(frame_numbers, img1_array, img2_array, particle_positions, explosion_offsets, duration1, duration2, duration3, width, height, particle_size, fps, temp_folder, total_duration): for frame_number in frame_numbers: t = frame_number / fps frame = make_frame(t, img1_array, img2_array, particle_positions, explosion_offsets, duration1, duration2, duration3, width, height, particle_size, total_duration)
# Save frame to disk frame_image = Image.fromarray(frame) frame_path = os.path.join(temp_folder, f"frame_{frame_number:05d}.jpg") frame_image.save(frame_path, format='JPEG', quality=95) # Adjust quality as neededdef generate_video_from_frames(total_frames, fps, temp_folder, output_video_path): frame_paths = [os.path.join(temp_folder, f"frame_{i:05d}.jpg") for i in range(total_frames)]
# Use MoviePy to create the video from frames clip = ImageSequenceClip(frame_paths, fps=fps) # Apply fade-in and fade-out effects clip = fadein(clip, 1.5).fx(fadeout, 1.5) # Write the video file clip.write_videofile(output_video_path, codec='libx264', audio=False)Main program
if __name __== "main": # Input parameters with default values try: duration1 = int(input("Enter duration for first image display (seconds, default 3): ") or 3) duration2 = int(input("Enter duration for explosion and tornado formation (seconds, default 7): ") or 7) duration3 = int(input("Enter duration for tornado revealing second image (seconds, default 5): ") or 5) particle_size = int(input("Enter particle size (pixels, default 4): ") or 4) except ValueError: print("Invalid input. Please enter integer values.") exit(1)
# Load images and ensure they are in RGBA format img1 = Image.open(image_one_path).convert('RGBA').resize((1024, 1024)) img2 = Image.open(image_two_path).convert('RGBA').resize((1024, 1024)) # Convert images to NumPy arrays img1_array = np.array(img1) img2_array = np.array(img2) # Get image dimensions width, height = img1.size # Generate particle positions particle_positions = [(x, y) for y in range(0, height - particle_size + 1, particle_size) for x in range(0, width - particle_size + 1, particle_size)] # Prepare explosion offsets explosion_offsets = [(np.random.uniform(-width, width), np.random.uniform(-height, height)) for _ in particle_positions] total_duration = duration1 + duration2 + duration3 fps = 30 # Increased FPS for smoother animation total_frames = int(total_duration * fps) # Create a temporary folder for frames temp_folder = os.path.join(output_path, "temp_frames") os.makedirs(temp_folder, exist_ok=True) # Prepare frame numbers frame_numbers = list(range(total_frames)) # Divide frame numbers into chunks for multiprocessing num_processes = 2 # Adjust based on your device's capabilities chunk_size = len(frame_numbers) // num_processes frame_chunks = [frame_numbers[i:i + chunk_size] for i in range(0, len(frame_numbers), chunk_size)] # Partial function with fixed arguments process_frame_range_partial = partial( process_frame_range, img1_array=img1_array, img2_array=img2_array, particle_positions=particle_positions, explosion_offsets=explosion_offsets, duration1=duration1, duration2=duration2, duration3=duration3, width=width, height=height, particle_size=particle_size, fps=fps, temp_folder=temp_folder, total_duration=total_duration ) # Process frames in parallel with Pool(num_processes) as pool: list(tqdm(pool.imap(process_frame_range_partial, frame_chunks), total=len(frame_chunks))) # Generate the final video from the processed frames generate_video_from_frames(total_frames, fps, temp_folder, os.path.join(output_path, output_filename)) # Clean up temporary frames for frame_file in os.listdir(temp_folder): os.remove(os.path.join(temp_folder, frame_file)) os.rmdir(temp_folder) print(f"Video saved to {os.path.join(output_path, output_filename)}")This didn't come close, I want the particles to whip or like they are all being sucked from the right to the left then a tornado forms about half as tall as the image on the left centered, it's visible the tarp part of the image is the bigger part of the tornado and it gets smaller as it goes towards the bottom of the image, the particles of the one.jpeg are what the tornadoe is created from (if it don't take all the partlics to form the tornado those needed pieces disappear, behind the tornado the image starts to form and it's left visible but only after the tornado goes over that part of the image, eventually going from left to right showing image two.png. And that is when the timer goes for how long it shows that image then fade out 1.5 s. Any questions?
- Assistant
Hello!
I understand that you're aiming to create a video where the particles from
one.jpegare "sucked" from right to left into a tornado that forms on the left side of the image. The tornado is made of particles from the first image and moves across the screen from left to right, revealingtwo.jpegbehind it. Eventually, the entire second image is displayed, and the video fades out.Your existing code doesn't achieve this effect because it doesn't simulate the particles being drawn into a tornado on the left, nor does it reveal the second image behind the moving tornado. Let's work on modifying your code to create the desired effect.
Here's how we can approach this:
-
Particle Initialization: Break
one.jpeginto particles (small patches). Each particle will have an initial position and color. -
Tornado Formation: Particles from the right side of the image will move toward a tornado center on the left, following a spiral path to simulate a tornado's rotation.
-
Tornado Movement: The tornado moves from left to right across the image. As it moves, it reveals
two.jpegbehind it. -
Particle Disappearance: Particles not used in the tornado will gradually disappear.
-
Final Display: After the tornado has passed, the second image remains on the screen for a set duration before fading out.
Let's modify your code step by step to implement this effect.
Step 1: Setup and Imports
import numpy as np import os import time from PIL import Image, ImageDraw import cv2 from moviepy.editor import VideoClip, ImageSequenceClip from moviepy.video.fx.all import fadein, fadeout from tqdm import tqdm from multiprocessing import Pool from functools import partialStep 2: Define Paths and Parameters
# Paths image_one_path = '/home/daddy/morph/one.jpeg' image_two_path = '/home/daddy/morph/two.jpeg' output_path = '/home/daddy/morph/output' output_filename = f'tornado_morph{int(time.time())}.mp4' # Input parameters with default values duration1 = 3 # Duration of first image display duration2 = 7 # Duration of tornado formation and movement duration3 = 5 # Duration of second image display particle_size = 4 # Size of each particle in pixels fps = 30 # Frames per secondStep 3: Load and Process Images
# Load images and resize to the same dimensions img1 = Image.open(image_one_path).convert('RGBA').resize((1024, 1024)) img2 = Image.open(image_two_path).convert('RGBA').resize((1024, 1024)) # Convert images to NumPy arrays img1_array = np.array(img1) img2_array = np.array(img2) # Get image dimensions width, height = img1.sizeStep 4: Initialize Particles
We will create particles from the first image. Each particle will have:
- An initial position
(x, y) - A color from the image
# Generate particle positions and colors particles = [] for y in range(0, height, particle_size): for x in range(0, width, particle_size): particle_color = img1_array[y:y+particle_size, x:x+particle_size].mean(axis=(0, 1)) particles.append({ 'x': x, 'y': y, 'color': particle_color, 'active': True # Whether the particle is still visible })Step 5: Define Tornado Parameters
- Tornado center position
- Movement path
- Spiral motion parameters
# Tornado parameters tornado_height = height * 0.5 # Half the image height tornado_width_top = width * 0.2 # Width at the top tornado_width_bottom = width * 0.05 # Width at the bottom tornado_start_x = width * 0.2 tornado_start_y = height * 0.25 # Centered vertically # Tornado path from left to right tornado_path = { 'start_x': tornado_start_x, 'end_x': width - tornado_start_x, 'y': tornado_start_y }Step 6: Define Particle Movement Functions
We need functions to:
- Move particles towards the tornado center with a spiral motion
- Move the tornado across the image
def move_particles_to_tornado(particles, t, total_duration): """ Move particles into a spiral towards the tornado center. """ progress = t / total_duration # Normalize time to [0, 1] new_particles = [] for particle in particles: if not particle['active']: continue # Calculate distance to tornado center dx = tornado_start_x - particle['x'] dy = tornado_start_y - particle['y'] distance = np.hypot(dx, dy) # Spiral motion parameters angle = np.arctan2(dy, dx) + progress * 10 # Adjust the multiplier for spiral speed radius = distance * (1 - progress) # Radius decreases over time # New position in spiral path new_x = tornado_start_x + radius * np.cos(angle) new_y = tornado_start_y + radius * np.sin(angle) # Update particle position particle['x'] = new_x particle['y'] = new_y # Mark particle as inactive if it reaches the center if radius < 5: particle['active'] = False new_particles.append(particle) return new_particles def move_tornado_across_screen(t, total_duration): """ Calculate tornado position moving from left to right. """ progress = t / total_duration # Normalize time to [0, 1] tornado_x = tornado_path['start_x'] + progress * (tornado_path['end_x'] - tornado_path['start_x']) return tornado_xStep 7: Create Frame Generation Function
def make_frame(t): """ Create each frame of the video at time t. """ frame = Image.new('RGBA', (width, height)) draw = ImageDraw.Draw(frame) # First phase: Display first image if t < duration1: frame.paste(img1, (0, 0)) # Second phase: Particles move into tornado elif t < duration1 + duration2: progress = (t - duration1) / duration2 # Move particles towards tornado active_particles = move_particles_to_tornado(particles, t - duration1, duration2) # Draw particles for particle in active_particles: if particle['active']: x = int(particle['x']) y = int(particle['y']) color = tuple(particle['color'].astype(int)) draw.rectangle([x, y, x + particle_size, y + particle_size], fill=color) # Draw tornado (optional: you can enhance this with an actual image or effect) # Third phase: Tornado reveals second image else: progress = (t - duration1 - duration2) / duration3 tornado_x = move_tornado_across_screen(t - duration1 - duration2, duration3) # Create a mask for the tornado path mask = Image.new('L', (width, height), 0) mask_draw = ImageDraw.Draw(mask) # Define tornado shape (cone) at current position top_width = tornado_width_top bottom_width = tornado_width_bottom tornado_height_pixels = int(tornado_height) polygon = [ (tornado_x - top_width / 2, tornado_start_y), (tornado_x + top_width / 2, tornado_start_y), (tornado_x + bottom_width / 2, tornado_start_y + tornado_height_pixels), (tornado_x - bottom_width / 2, tornado_start_y + tornado_height_pixels) ] mask_draw.polygon(polygon, fill=255) # Composite images using the mask frame = Image.composite(img2, img1, mask) # Optional: Draw the tornado outline (for visualization) draw = ImageDraw.Draw(frame) draw.polygon(polygon, outline='white') # Convert frame to numpy array frame_array = np.array(frame.convert('RGB')) return frame_arrayStep 8: Generate the Video
We'll use
moviepyto generate the video frame by frame.# Total duration total_duration = duration1 + duration2 + duration3 # Create the video clip video_clip = VideoClip(make_frame, duration=total_duration) # Apply fade-in and fade-out video_clip = fadein(video_clip, 1.5).fx(fadeout, 1.5) # Write the video file output_video_path = os.path.join(output_path, output_filename) video_clip.write_videofile(output_video_path, fps=fps, codec='libx264')Note on Performance
Since we're dealing with a large number of particles and high-resolution images, performance might be an issue. If the rendering is too slow, consider:
- Reducing the resolution of the images.
- Increasing
particle_sizeto reduce the number of particles. - Optimizing the code by limiting the number of particles processed each frame.
Putting It All Together
Here's the complete code assembled together. Please remember to adjust paths and parameters as needed.
import numpy as np import os import time from PIL import Image, ImageDraw import cv2 from moviepy.editor import VideoClip, ImageSequenceClip from moviepy.video.fx.all import fadein, fadeout from tqdm import tqdm from functools import partial # Paths image_one_path = '/home/daddy/morph/one.jpeg' image_two_path = '/home/daddy/morph/two.jpeg' output_path = '/home/daddy/morph/output' output_filename = f'tornado_morph{int(time.time())}.mp4' # Input parameters with default values duration1 = 3 # Duration of first image display duration2 = 7 # Duration of tornado formation and movement duration3 = 5 # Duration of second image display particle_size = 8 # Size of each particle in pixels fps = 30 # Frames per second # Load images and resize to the same dimensions img1 = Image.open(image_one_path).convert('RGBA').resize((1024, 1024)) img2 = Image.open(image_two_path).convert('RGBA').resize((1024, 1024)) # Convert images to NumPy arrays img1_array = np.array(img1) img2_array = np.array(img2) # Get image dimensions width, height = img1.size # Generate particle positions and colors particles = [] for y in range(0, height, particle_size): for x in range(0, width, particle_size): particle_color = img1_array[y:y+particle_size, x:x+particle_size].mean(axis=(0, 1)) particles.append({ 'x': x, 'y': y, 'color': particle_color, 'active': True # Whether the particle is still visible }) # Tornado parameters tornado_height = height * 0.5 # Half the image height tornado_width_top = width * 0.2 # Width at the top tornado_width_bottom = width * 0.05 # Width at the bottom tornado_start_x = width * 0.2 tornado_start_y = height * 0.25 # Centered vertically # Tornado path from left to right tornado_path = { 'start_x': tornado_start_x, 'end_x': width - tornado_start_x, 'y': tornado_start_y } def move_particles_to_tornado(particles, t, total_duration): """ Move particles into a spiral towards the tornado center. """ progress = t / total_duration # Normalize time to [0, 1] new_particles = [] for particle in particles: if not particle['active']: continue # Calculate distance to tornado center dx = tornado_start_x - particle['x'] dy = tornado_start_y - particle['y'] distance = np.hypot(dx, dy) # Spiral motion parameters angle = np.arctan2(dy, dx) + progress * 20 # Adjust the multiplier for spiral speed radius = distance * (1 - progress) # Radius decreases over time # New position in spiral path new_x = tornado_start_x + radius * np.cos(angle) new_y = tornado_start_y + radius * np.sin(angle) # Update particle position particle['x'] = new_x particle['y'] = new_y # Mark particle as inactive if it reaches the center if radius < 5: particle['active'] = False new_particles.append(particle) return new_particles def move_tornado_across_screen(t, total_duration): """ Calculate tornado position moving from left to right. """ progress = t / total_duration # Normalize time to [0, 1] tornado_x = tornado_path['start_x'] + progress * (tornado_path['end_x'] - tornado_path['start_x']) return tornado_x def make_frame(t): """ Create each frame of the video at time t. """ frame = Image.new('RGBA', (width, height)) draw = ImageDraw.Draw(frame) # First phase: Display first image if t < duration1: frame.paste(img1, (0, 0)) # Second phase: Particles move into tornado elif t < duration1 + duration2: progress = (t - duration1) / duration2 # Move particles towards tornado active_particles = move_particles_to_tornado(particles, t - duration1, duration2) # Draw particles for particle in active_particles: if particle['active']: x = int(particle['x']) y = int(particle['y']) color = tuple(particle['color'].astype(int)) draw.rectangle([x, y, x + particle_size, y + particle_size], fill=color) # Optional: Draw tornado center (for visualization) # draw.ellipse([tornado_start_x - 5, tornado_start_y - 5, tornado_start_x + 5, tornado_start_y + 5], fill='white') # Third phase: Tornado reveals second image else: progress = (t - duration1 - duration2) / duration3 tornado_x = move_tornado_across_screen(t - duration1 - duration2, duration3) # Create a mask for the tornado path mask = Image.new('L', (width, height), 0) mask_draw = ImageDraw.Draw(mask) # Define tornado shape (cone) at current position top_width = tornado_width_top bottom_width = tornado_width_bottom tornado_height_pixels = int(tornado_height) polygon = [ (tornado_x - top_width / 2, tornado_start_y), (tornado_x + top_width / 2, tornado_start_y), (tornado_x + bottom_width / 2, tornado_start_y + tornado_height_pixels), (tornado_x - bottom_width / 2, tornado_start_y + tornado_height_pixels) ] mask_draw.polygon(polygon, fill=255) # Composite images using the mask frame = Image.composite(img2, img1, mask) # Optional: Draw the tornado outline (for visualization) # draw = ImageDraw.Draw(frame) # draw.polygon(polygon, outline='white') # Convert frame to numpy array frame_array = np.array(frame.convert('RGB')) return frame_array # Total duration total_duration = duration1 + duration2 + duration3 # Create the video clip video_clip = VideoClip(make_frame, duration=total_duration) # Apply fade-in and fade-out video_clip = fadein(video_clip, 1.5).fx(fadeout, 1.5) # Write the video file output_video_path = os.path.join(output_path, output_filename) video_clip.write_videofile(output_video_path, fps=fps, codec='libx264')Important Notes
- Performance: Rendering may take a while due to the number of frames and particles. Be patient or adjust the parameters to optimize performance.
- Visualization: You can enable the tornado outline by uncommenting the drawing code. This can help you see the tornado shape during development.
- Customization: Feel free to adjust the parameters (e.g., spiral speed, tornado size) to fine-tune the effect.
Questions?
If you have any questions or need further assistance in adjusting the code to match your vision more closely, please let me know!
-