Alright, let's walk through how to create a polished image slideshow using OpenCV—one that cycles through images in a specified folder and adds smooth fade transitions between each slide. I'll break this down into actionable steps with working code and plain-language explanations.

Overview #

The core plan is simple: we'll load all valid images from your target folder, standardize their sizes (so transitions don't look jarring), display each image for a set duration, then use a fade-in/fade-out effect to switch to the next one. We'll also add a clean way to exit the slideshow at any time.

Step-by-Step Implementation #

1. Import Required Libraries #

First, grab the tools we need: OpenCV for image handling, os for folder navigation, and numpy for smooth value interpolation:

import cv2
import os
import numpy as np

2. Load and Preprocess Images #

We'll write a helper function to load images, filter out non-image files, and resize everything to a consistent size. This ensures transitions stay smooth (no sudden window jumps):

def load_images_from_folder(folder, target_size=(800, 600)):
    images = []
    # Define which file counts as an image
    valid_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff')
    
    for filename in os.listdir(folder):
        if filename.lower().endswith(valid_extensions):
            img_path = os.path.join(folder, filename)
            img = cv2.imread(img_path)
            
            if img is not None:
                # Resize to your preferred dimensions—tweak this as needed
                img = cv2.resize(img, target_size)
                images.append(img)
    
    return images

3. Core Slideshow Logic #

The main function handles the loop: displaying images, waiting between slides, and executing the fade transition. We use cv2.addWeighted() to blend two images smoothly over a series of frames:

def main():
    # Replace this with your actual image folder path
    image_folder = 'path/to/your/image/folder'
    # Set your desired display size
    target_size = (800, 600)
    # How long each image stays on screen (in milliseconds)
    display_duration = 3000
    # Number of frames for the fade—more frames = smoother transition
    transition_frames = 30

    # Load and prep images
    images = load_images_from_folder(image_folder, target_size)
    if not images:
        print("No valid images found in the folder!")
        return

    num_images = len(images)
    current_idx = 0

    while True:
        # Show the current image
        cv2.imshow('OpenCV Slideshow', images[current_idx])
        
        # Wait for the set duration, check for ESC key to exit
        key = cv2.waitKey(display_duration)
        if key == 27:  # ESC key ASCII code
            break

        # Get the next image (loop back to first after last)
        next_idx = (current_idx + 1) % num_images
        current_img = images[current_idx]
        next_img = images[next_idx]

        # Run the fade transition
        for alpha in np.linspace(0, 1, transition_frames):
            # Blend images: current fades out, next fades in
            blended = cv2.addWeighted(current_img, 1 - alpha, next_img, alpha, 0)
            cv2.imshow('OpenCV Slideshow', blended)
            
            # Keep transition smooth (~60 FPS) and check for exit
            if cv2.waitKey(16) == 27:
                cv2.destroyAllWindows()
                return

        # Update index for the next loop
        current_idx = next_idx

    # Clean up windows when exiting
    cv2.destroyAllWindows()

if __name__ == "__main__":
    main()

Key Details Explained #

• Image Standardization: Resizing all images to the same size prevents sudden shifts in the window during transitions. If you want to preserve aspect ratio instead of stretching, you can add black padding to images that don't match the target dimensions.
• Fade Transition: cv2.addWeighted() mixes two images using weights 1-alpha and alpha. By incrementing alpha from 0 to 1 over transition_frames, we get a seamless fade between slides.
• Exit Handling: We listen for the ESC key both during image display and transitions, so you can exit at any time without crashing.

Extra Optimization Tips #

• Preserve Aspect Ratio: Modify the load_images_from_folder function to add black borders instead of stretching images. Calculate the scaling factor to fit the image within the target size, then add padding to reach the exact dimensions.
• More Transition Effects: Try slide transitions (shift the current image out while sliding the next in) or dissolve effects (randomly replace pixels over time).
• Add Image Labels: Use cv2.putText() to display the filename of each image on screen.
• Adjust Timings: Tweak display_duration and transition_frames to match your preferred pace. For example, 60 transition frames at 16ms per frame gives a 1-second transition.

内容的提问来源于stack exchange，提问作者Vahid Reza