Creating Timelapses of Earth with the NASA EPIC API, Python, Flask

· Dr Soukkou Youcef

In this blog post, I’ll walk you through a project I recently completed: creating a timelapse video using Python, Flask, and NASA’s EPIC API. This project combines web development, image processing, and API integration to generate stunning timelapse videos of Earth from space. Whether you’re a beginner or an experienced developer, this guide will help you understand the process and build your own version of this project.

What is the EPIC API?

NASA’s Earth Polychromatic Imaging Camera (EPIC) captures high-resolution images of Earth from the Deep Space Climate Observatory (DSCOVR) satellite. These images are publicly available through the EPIC API, which provides access to daily snapshots of our planet.

You can learn more about the EPIC API here.

Project Overview

The goal of this project is to:

  1. Fetch images from the EPIC API for a specified date range.
  2. Download and process these images.
  3. Generate a timelapse video using OpenCV.
  4. Serve the video through a Flask web application.

Here’s a breakdown of the steps involved:

  1. Backend Development:

    • Fetch images from the EPIC API.
    • Download and process images.
    • Generate a timelapse video using OpenCV.
    • Handle user requests and cancellations.

  2. Frontend Development:

    • Create a user-friendly interface for selecting dates and viewing the timelapse.
    • Display progress and allow users to cancel the process.

  3. Deployment:

    • Push the code to GitHub.
    • Deploy the application (optional).

Technologies Used

  • Python: The core programming language for backend logic.
  • Flask: A lightweight web framework for serving the application.
  • OpenCV: A computer vision library for creating the timelapse video.
  • NASA EPIC API: For fetching Earth images.
  • Bootstrap: For styling the frontend.
  • Git/GitHub: For version control and collaboration.

Step-by-Step Implementation

1. Setting Up the Backend

The backend is responsible for fetching images from the EPIC API, downloading and processing them, and generating a timelapse video. Here’s how it works:

  1. Fetching Images:

    • The EPIC API provides images for specific dates. We use Python’s requests library to fetch these images for a given date range.

  2. Downloading and Processing Images:

    • Once we have the image URLs, we download and save them locally. This ensures we have all the necessary images before creating the timelapse.

  3. Generating the Timelapse Video:

    • Using OpenCV, we create a video from the downloaded images. The video is saved in a web-friendly format (e.g., MP4 with H.264 encoding).

  4. Handling User Requests:

    • The backend also handles user requests, such as starting the timelapse creation process and cancelling it if needed.

2. Building the Frontend

The frontend provides a user-friendly interface for interacting with the backend. It allows users to:

  1. Select a Date Range:

    • Users can specify the start and end dates for the timelapse.

  2. View Progress:

    • The frontend displays the progress of the timelapse creation, including the number of images downloaded and the current status.

  3. Cancel the Process:

    • If the user decides to cancel the process, the frontend sends a cancellation request to the backend.

The frontend is built using HTML, CSS, and Bootstrap for a clean and responsive design.

3. Integrating Backend and Frontend

The backend and frontend are connected using Flask, a lightweight web framework for Python. The backend handles API requests, image processing, and video generation, while the frontend provides a user-friendly interface for interacting with the backend.

4. Pushing Code to GitHub

Once the project is complete, you can push it to GitHub for version control and collaboration. This involves:

  1. Initializing a Git repository.
  2. Adding files and committing changes.
  3. Linking the local repository to GitHub and pushing the code.

Challenges and Solutions

  1. Handling Large Datasets:

    • Fetching and processing a large number of images can be resource-intensive. To mitigate this, I implemented a cancellation feature and optimized the image processing pipeline.

  2. Browser Compatibility:

    • To ensure the timelapse video plays on all browsers, I used the widely supported H.264 codec for encoding.

  3. User Experience:

    • I added a progress bar and cancellation button to improve the user experience.

Conclusion

This project was a great way to explore the intersection of web development, image processing, and API integration. By combining Python, Flask, and NASA’s EPIC API, I was able to create a tool that generates stunning timelapse videos of Earth from space.

You can find the complete code on My GitHub. Feel free to fork the repository, experiment with the code, and create your own version!

Next Steps

  • Add support for custom frame rates and video resolutions.
  • Deploy the application to a cloud platform (e.g., Heroku or AWS).
  • Explore other APIs for additional data sources.
  • Maybe add smoothing and interpolation to the timelapses.

I hope you enjoyed this blog post! If you have any questions or suggestions, feel free to reach out. Happy coding! 🚀

Created by Youcef Soukkou
Email: soukkouyoucef@protonmail.com
GitHub: https://github.com/joe1999999