Timelapse images become blurry over time

[JDadders]

I have a script that captures a series of images over time in a timelapse using the raspberry pi camera module 3 wide as the camera.

There is a problem though. The first image in the sequence is sharp but the focus of subsequent images becomes increasingly blurry over time. It doesn't matter how long the interval is between photos (I've tried a few seconds and multiple minutes) it always happens.

Before starting the capture process I set the camera's focus to infinity and give sufficient time for the change to be adopted by the camera before starting to capture so theoretically the first photo should have the same properties as the last. I've tried manually forcing the focus to infinity before every shot but that doesn't seem to help.

Here's some sample images. You'll need to view them full-size and look at the trees to see the blurriness. The first image is the first image in the timelapse sequence, the second image is the 24th image in the timelapse sequence.

Here's the relevant code snippet:

            with Picamera2() as picam2:
                # Configure the camera
                config = picam2.create_still_configuration(raw={}, display=None)
                picam2.configure(config)
                
                # Enable HDR
                if HDR_ENABLED == True:
                    os.system("v4l2-ctl --set-ctrl wide_dynamic_range=1 -d /dev/v4l-subdev0")
                else:
                    os.system("v4l2-ctl --set-ctrl wide_dynamic_range=0 -d /dev/v4l-subdev0")       

                # Start the preview
                picam2.set_controls({"AfMode": controls.AfModeEnum.Manual, "LensPosition": 0.0})
                picam2.set_controls({"NoiseReductionMode": controls.draft.NoiseReductionModeEnum.HighQuality})
                picam2.options['quality'] = 95
                picam2.start()
                time.sleep(2)  # Allow camera to warm up and adjust                       
                for i in range(num_smooth_intro_photos + num_sunset_photos):
                    start_time = timeit.default_timer()

                    # Capture a photo using the camera
                    timestamp = time.strftime("%Y%m%d-%H%M%S")
                    file_name = os.path.join(script_directory, f"sunset_photo_{timestamp}_seq_{i + 1}.jpg")                    
                    file_name_dng = os.path.join(script_directory, f"frame_{i + 1:04}.dng")                   

                    # Capture the image to a file
                    r = picam2.switch_mode_capture_request_and_stop(config)
                    r.save("main", file_name)
                    
                    if(HDR_video == True):
                        r.save_dng(file_name_dng)
                        file_name_tiff = video_generator.convert_DNG_to_TIFF(file_name_dng)
                    
                    r.release()
                    picam2.configure("preview")
                    picam2.start()

                    if(HDR_video == True):
                        image_files.append(file_name_tiff)
                    else:
                        image_files.append(file_name)
                                        
                    # Queue the photo for upload to Google Drive
                    upload_queue.put((file_name, folder_name))
                    
                    if(HDR_video == True):
                        os.remove(file_name_dng)

                    # Wait for the user-defined interval before taking the next photo
                    if i < num_smooth_intro_photos + num_sunset_photos - 1:  # Skip sleep after the last photo
                        elapsed_time = timeit.default_timer() - start_time

                        if i < num_smooth_intro_photos:  # Smooth transition phase
                            x = i / (num_smooth_intro_photos - 1)  # normalize x between 0 and 1
                            sleep_time = SMOOTH_INTRO_CAPTURE_INTERVAL + (CAPTURE_INTERVAL - SMOOTH_INTRO_CAPTURE_INTERVAL) * smoothstep(0, 1, x)
                        else:  # Sunset phase
                            sleep_time = CAPTURE_INTERVAL

                        sleep_time = max(sleep_time - elapsed_time, 0)
                        print(f"Sleep time: {sleep_time}")
                        time.sleep(sleep_time)
            
                # Close the camera
                picam2.close()             

[davidplowman]

Hi, it's hard to know exactly what to expect. The lens positions are only approximate in the first place (there is some degree of variation between modules), and we also know that lens positions can change a bit with time as the things warm up. The exact amount of this variation, however, is not something I really know.

It might be worth putting the lens into continuous AF mode, or to try running an AF cycle prior to each capture. Might that help?