Create a 3D Dynamic Universe Generator with Python

Introduction

Interesting Introduction

Have you ever looked up at the starry sky and imagined creating a universe with your own code? Today we will realize this dream! By programming in Python, we will build a 3D dynamic universe generator that allows you to simulate the magnificent beauty of the starry sky on your screen.

This is not only a programming practice but also a wonderful collision between astronomy and technology. Don’t worry about complex calculations or celestial formulas; we will guide you step by step to build your own “little universe” in an easy-to-understand way.

Development Background and Tool Selection

Library and Tool Introduction

To implement a 3D dynamic universe generator, we need the support of the following tools and libraries:

1. matplotlib (optional) for 3D graphics rendering, helping us display the positions of stars in three-dimensional space.
2. numpy for generating random star positions and processing data.
3. matplotlib.animation to add dynamic effects to our universe.
4. random to help generate random colors and star attributes, increasing the diversity of the universe.

With these tools, we will easily implement the dynamic universe generator. Once completed, you will see a three-dimensional starry sky simulation and even be able to rotate the view to observe the movement of the stars!

Function Module Development

Module 1: Building the Basic 3D Universe

The first step is to create a three-dimensional space and randomly generate several “stars” within it.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def generate_universe(num_stars=1000):
    # Randomly generate the 3D coordinates of stars
    x = np.random.uniform(-1, 1, num_stars)
    y = np.random.uniform(-1, 1, num_stars)
    z = np.random.uniform(-1, 1, num_stars)
    
    # Return the 3D coordinates
    return x, y, z

# Create 3D plotting window
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Generate positions for 1000 stars
x, y, z = generate_universe()

# Plot stars
ax.scatter(x, y, z, c="white", s=1)
ax.set_facecolor("black")  # Set background to black
plt.title("Static 3D Universe")
plt.show()

Effect Display: After running the code, you will see a static three-dimensional starry sky view, with stars randomly distributed against a black background, resembling the stars in the night sky.

Module 2: Adding Dynamic Effects to the Universe

Next, we will make these stars move. Here we assume that the stars rotate around a central point (the origin), simulating dynamic effects in the universe.

Core Logic:

1. Use a rotation matrix to update the coordinates of the stars.
2. Use matplotlib.animation to achieve dynamic drawing.

from matplotlib.animation import FuncAnimation

def rotate_stars(x, y, z, angle):
    """Rotate stars using a rotation matrix"""
    # Rotation matrix (rotate around Z-axis)
    cos_theta = np.cos(angle)
    sin_theta = np.sin(angle)
    x_new = cos_theta * x - sin_theta * y
    y_new = sin_theta * x + cos_theta * y
    
    return x_new, y_new, z  # z coordinates remain unchanged

# Initialize plotting
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_facecolor("black")

# Dynamic update function
def update(frame):
    global x, y, z
    ax.clear()
    ax.set_facecolor("black")
    
    # Rotate stars
    angle = frame * 0.01
    x_new, y_new, z_new = rotate_stars(x, y, z, angle)
    
    # Plot stars
    ax.scatter(x_new, y_new, z_new, c="white", s=1)
    plt.title("Dynamic 3D Universe")

# Generate animation
ani = FuncAnimation(fig, update, frames=360, interval=30)
plt.show()

Effect Display: After running, the stars will slowly rotate around the origin, presenting a dynamic universe scene.

Module 3: Enriching the Visual Effects of the Universe

To make the universe more visually appealing, we can:

1. Add random colors to the stars.
2. Simulate changes in the brightness of the stars (by varying their size).

def generate_colored_universe(num_stars=1000):
    # Generate star coordinates
    x = np.random.uniform(-1, 1, num_stars)
    y = np.random.uniform(-1, 1, num_stars)
    z = np.random.uniform(-1, 1, num_stars)
    
    # Randomly generate colors and sizes
    colors = np.random.choice(["white", "yellow", "blue", "red"], num_stars)
    sizes = np.random.uniform(1, 5, num_stars)
    
    return x, y, z, colors, sizes

# Update drawing function
def update(frame):
    global x, y, z, colors, sizes
    ax.clear()
    ax.set_facecolor("black")
    
    # Rotate stars
    angle = frame * 0.01
    x_new, y_new, z_new = rotate_stars(x, y, z, angle)
    
    # Plot stars
    for i in range(len(x_new)):
        ax.scatter(x_new[i], y_new[i], z_new[i], c=colors[i], s=sizes[i])
    plt.title("Dynamic 3D Universe with Effects")

# Generate stars with colors and sizes
x, y, z, colors, sizes = generate_colored_universe()

# Dynamically display the universe with effects
ani = FuncAnimation(fig, update, frames=360, interval=30)
plt.show()

Effect Display: This version of the dynamic universe adds colorful stars and changes in brightness, making the visual effect closer to a real starry sky.

Extensions and Optimizations

1. Add Galaxy Structure: Simulate spiral structures similar to the Milky Way, generating initial star distribution using polar coordinates.
2. Simulate Star Birth and Death: Add a lifecycle to the stars, allowing them to randomly extinguish or be newly generated.
3. Enhance Interactivity: Use keyboard or mouse controls to adjust the view or speed of star movement.
4. Cross-Platform Compatibility: Export the generated dynamic universe as a GIF or video to share on social platforms.

Conclusion

Through this tutorial, you have learned how to implement a 3D dynamic universe generator using Python. From building a three-dimensional starry sky to realizing dynamic effects and visual optimizations, you have completed a full project development!

Now it’s your turn to unleash your creativity—try adding more elements to the universe, such as planets, comet trails, or give stars more physical characteristics. Once completed, feel free to share your work, and let’s explore greater possibilities together!

Recommended Learning Resources:

• Numpy Official Documentation
• Matplotlib Official Documentation
• Python Animation Production

Let’s explore the infinite possibilities of the universe with code! 🚀