Моделирование квантовой пены

[MakarovDs]

Ну вот наконец у нас получилась виртуализация квантовой пены более менее что-то похожее на неё

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.ndimage import gaussian_filter
from skimage import measure

# Настройка интерактивного режима Matplotlib
plt.ion()

# Создание окна для графика
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Задание значения изоповерхности
isoval = 0.5

# Функция для генерации случайных данных и визуализации изоповерхности
def generate_and_plot():
    # Генерация случайных данных
    np.random.seed(np.random.randint(0, 1000))
    data = np.random.rand(50, 50, 50)

    # Фильтрация данных
    data = gaussian_filter(data, sigma=2)

    # Создание изоповерхности
    verts, faces, _, _ = measure.marching_cubes(data, isoval)

    # Визуализация изоповерхности
    ax.clear()
    ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], triangles=faces, cmap='viridis', alpha=0.5)

    # Настройка освещения
    ax.set_axis_off()
    ax.set_aspect('equal')
    ax.view_init(elev=30, azim=60)

    # Пауза для анимации
    plt.pause(0.5)

# Генерация и визуализация случайных данных в цикле
while True:
    generate_and_plot()

# Выключение интерактивного режима Matplotlib
plt.ioff()

Но конечное же это не то что хотелось бы.

[MakarovDs]

Но вот теперь мы можем создать игру где мы будем перемещаться в квантовой пене что-бы получше её разглядеть...

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import numpy as np
from scipy.ndimage import gaussian_filter
from skimage import measure

# Инициализация Pygame
pygame.init()
display = (800, 600)
pygame.display.set_mode(display, DOUBLEBUF|OPENGL)

# Настройка перспективы
gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)
glTranslatef(0.0, -1.0, -5)

# Задание значения изоповерхности
isoval = 0.5

# Угол обзора камеры
angle_x = 0
angle_y = 0

# Функция для генерации квантовой пены
def generate_quantum_foam():
    # Генерация случайных данных
    np.random.seed(np.random.randint(0, 1000))
    data = np.random.rand(50, 50, 50)

    # Фильтрация данных
    data = gaussian_filter(data, sigma=2)

    # Создание изоповерхности
    verts, faces, _, _ = measure.marching_cubes(data, isoval)

    # Отрисовка изоповерхности
    glBegin(GL_TRIANGLES)
    for face in faces:
        for vert in face:
            glVertex3fv(verts[vert] * 0.1)
    glEnd()

# Основной цикл
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()

    # Управление камерой с помощью клавиш
    keys = pygame.key.get_pressed()
    if keys[pygame.K_w]:
        glTranslatef(0, 0, 0.1)
    if keys[pygame.K_s]:
        glTranslatef(0, 0, -0.1)
    if keys[pygame.K_a]:
        glTranslatef(-0.1, 0, 0)
    if keys[pygame.K_d]:
        glTranslatef(0.1, 0, 0)

    # Управление камерой с помощью мыши
    mouse_buttons = pygame.mouse.get_pressed()
    if mouse_buttons[0]:  # Левая кнопка мыши
        mouse_pos = pygame.mouse.get_pos()
        angle_x += (mouse_pos[1] - display[1] // 2) * 0.01
        angle_y += (mouse_pos[0] - display[0] // 2) * 0.01
        glRotatef(angle_x, 1, 0, 0)
        glRotatef(angle_y, 0, 1, 0)
        pygame.mouse.set_pos((display[0] // 2, display[1] // 2))

    # Отрисовка сцены
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
    generate_quantum_foam()
    pygame.display.flip()
    pygame.time.wait(10)

Правда она белая, и всё лагает но это исправимо...

[MakarovDs]

Поэтому я решил вернуться к той пене которая лучше всего у меня получилась, и натянуть на её меш mgrid, и мы уже почти подошли к той квантовой пене которая получилось у Деррика Лейнвебера вот код:

import numpy as np
from mayavi import mlab
import noise as perlin_noise
import time

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)
scale = 10.0

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base):
    noise = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise[i][j][k] = perlin_noise.pnoise3(i/scale,
                                                     j/scale,
                                                     k/scale,
                                                     octaves=octaves,
                                                     persistence=persistence,
                                                     lacunarity=lacunarity,
                                                     repeatx=shape[0],
                                                     repeaty=shape[1],
                                                     repeatz=shape[2],
                                                     base=int(base))
    return normalize_noise(noise)

# Создание 3D-сетки
x, y, z = np.mgrid[0:10:32j, 0:10:32j, 0:10:32j]

# Функция для обновления кадра
def update(base):
    noise = generate_noise(base)
    U = np.where(noise > 0.5, noise, noise.min())  # Устанавливаем значение в минимальное, если шум ниже 0.5
    U = normalize_noise(U)  # Нормализация массива U
    mlab.clf()  # Очистка текущего кадра
    mlab.contour3d(U, contours=[0.5])  # Создание контура шума

# Запуск анимации
base = 0  # Начальная база
for i in range(100):
    base += 1  # Изменяем базу на 1
    update(base)
    mlab.draw()
    time.sleep(0.1)  # Пауза между кадрами
mlab.show()  # Отображение окна Mayavi

Хотя на первый взгляд это больше похоже на то как выглядит алгоритм вороной для генерации пещер майнкрафта...

[MakarovDs]

Нашел пчелиные соты вот

import numpy as np
from mayavi import mlab
import noise as perlin_noise
import time
import random

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base, scale):
    noise = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise[i][j][k] = perlin_noise.pnoise3(i/scale,
                                                     j/scale,
                                                     k/scale,
                                                     octaves=octaves,
                                                     persistence=persistence,
                                                     lacunarity=lacunarity,
                                                     repeatx=shape[0],
                                                     repeaty=shape[1],
                                                     repeatz=shape[2],
                                                     base=int(base))
    return normalize_noise(noise)

# Создание 3D-сетки
x, y, z = np.mgrid[0:10:32j, 0:10:32j, 0:10:32j]

# Функция для обновления кадра
def update():
    base = random.randint(0, 1000)  # Случайный base для каждого кадра
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого кадра
    noise = generate_noise(base, scale)
    U = np.where(noise > 0.5, noise, noise.min())  # Устанавливаем значение в минимальное, если шум ниже 0.5
    U = normalize_noise(U)  # Нормализация массива U
    mlab.clf()  # Очистка текущего кадра
    mlab.contour3d(U, contours=[0.5])  # Создание контура шума

# Запуск анимации
for i in range(100):
    update()
    mlab.draw()
    time.sleep(0.1)  # Пауза между кадрами
mlab.show()  # Отображение окна Mayavi

И рублённую щепку



И рубленные соты


И даже суперсоты


А что это такое я вообще не понимаю...

[MakarovDs]

Вообщем мне так понравилась квантовая пена что я решил её переписать на blender

import bpy
import numpy as np

# Параметры шума
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума
shape = (32, 32, 32)
noise = np.zeros(shape)

# Генерация шума
for i in range(shape[0]):
    for j in range(shape[1]):
        for k in range(shape[2]):
            noise[i, j, k] = np.random.rand()

# Нормализация шума
noise = noise / noise.max()

# Создание 3D-сетки
x, y, z = np.mgrid[0:10:32j, 0:10:32j, 0:10:32j]

# Функция для обновления кадра
def update(scene):
    # Генерация шума
    noise = np.random.rand(*shape)
    noise = noise / noise.max()

    # Создание меша из шума
    mesh = bpy.data.meshes.new("NoiseMesh")
    obj = bpy.data.objects.new("NoiseObject", mesh)
    scene.collection.objects.link(obj)

    # Заполнение меша данными
    mesh.from_pydata(np.array([x.ravel(), y.ravel(), z.ravel()]).T, [], np.array([noise.ravel()]))
    mesh.update(calc_edges=True)

    # Удаление старого меша
    for obj in scene.collection.objects:
        if obj.name.startswith("NoiseObject"):
            scene.collection.objects.unlink(obj)
            bpy.data.objects.remove(obj)

# Запуск анимации
bpy.context.scene.frame_end = 100
for frame in range(100):
    bpy.context.scene.frame_set(frame)
    update(bpy.context.scene)
    bpy.context.scene.render.filepath = f"frame_{frame:03d}.png"
    bpy.ops.render.render(write_still=True)

Получилось сюрреалистично...

[MakarovDs]

Короче у меня возникла проблема из-за установки bulder-tools теперь не могу запустить свой код там где пчелиные соты выдает ошибку:

Traceback (most recent call last):
File "tvtk_classes\tvtk_helper.py", line 22, in get_module
ModuleNotFoundError: No module named 'tvtk.custom.light'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "g:\EVP-Spaces\EVP-Stage-Space.py", line 2, in <module>
from mayavi import mlab
File "C:\Python312\Lib\site-packages\mayavi\mlab.py", line 16, in <module>
from mayavi.tools.camera import view, roll, yaw, pitch, move
File "C:\Python312\Lib\site-packages\mayavi\tools\camera.py", line 24, in <module>
from .engine_manager import get_engine
File "C:\Python312\Lib\site-packages\mayavi\tools\engine_manage r.py", line 15, in <module>
from mayavi.core.engine import Engine
File "C:\Python312\Lib\site-packages\mayavi\core\engine.py", line 27, in <module>
from mayavi.core.base import Base
File "C:\Python312\Lib\site-packages\mayavi\core\base.py", line 19, in <module>
from tvtk.pyface.tvtk_scene import TVTKScene
File "C:\Python312\Lib\site-packages\tvtk\pyface\tvtk_scene.py" , line 25, in <module>
from tvtk.pyface import light_manager
File "C:\Python312\Lib\site-packages\tvtk\pyface\light_manager. py", line 130, in <module>
class CameraLight(HasTraits):
File "C:\Python312\Lib\site-packages\tvtk\pyface\light_manager. py", line 146, in CameraLight
source = Instance(tvtk.Light, ())
^^^^^^^^^^
File "tvtk_classes\tvtk_helper.py", line 273, in <lambda>
File "tvtk_classes\tvtk_helper.py", line 47, in get_class
File "tvtk_classes\tvtk_helper.py", line 28, in get_module
File "tvtk_classes\light.py", line 12, in <module>
File "C:\Python312\Lib\site-packages\tvtk\array_handler.py", line 29, in <module>
from tvtk.array_ext import set_id_type_array
File "array_ext.pyx", line 1, in init array_ext
ValueError: numpy.dtype size changed, may indicate binary incompatibility. Expected 96 from C header, got 88 from PyObject

Я уже решал эту проблему раньше но уже непомню как... И поэтому я решил переписать свой код аморфных фигур на другие библиотеки но получилось не очень не то что я хотел:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import noise as perlin_noise
import time
import random
from skimage import measure

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base, scale):
    noise = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise[i][j][k] = perlin_noise.pnoise3(i/scale,
                                                     j/scale,
                                                     k/scale,
                                                     octaves=octaves,
                                                     persistence=persistence,
                                                     lacunarity=lacunarity,
                                                     repeatx=shape[0],
                                                     repeaty=shape[1],
                                                     repeatz=shape[2],
                                                     base=int(base))
    return normalize_noise(noise)

# Функция для обновления кадра
def update(ax):
    base = random.randint(0, 1000)  # Случайный base для каждого кадра
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого кадра
    noise = generate_noise(base, scale)
    U = np.where(noise > 0.5, noise, noise.min())  # Устанавливаем значение в минимальное, если шум ниже 0.5
    U = normalize_noise(U)  # Нормализация массива U

    ax.clear()  # Очистка текущего окна

    x, y, z = np.indices(U.shape)
    ax.scatter(x.ravel(), y.ravel(), z.ravel(), c=U.ravel(), cmap='viridis', alpha=0.1)

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(U, level=0.5)
    ax.plot_trisurf(verts[:, 0], verts[:, 1], faces, verts[:, 2], color='r', alpha=0.5)

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

for i in range(100):
    update(ax)
    plt.pause(0.1)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Отображение окончательного кадра

[MakarovDs]

Вот версия с чисто mgrid сеткой:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import noise as perlin_noise
import time
import random
from skimage import measure

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base, scale):
    noise = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise[i][j][k] = perlin_noise.pnoise3(i/scale,
                                                     j/scale,
                                                     k/scale,
                                                     octaves=octaves,
                                                     persistence=persistence,
                                                     lacunarity=lacunarity,
                                                     repeatx=shape[0],
                                                     repeaty=shape[1],
                                                     repeatz=shape[2],
                                                     base=int(base))
    return normalize_noise(noise)

# Функция для обновления кадра
def update(ax):
    base = random.randint(0, 1000)  # Случайный base для каждого кадра
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого кадра
    noise = generate_noise(base, scale)
    U = np.where(noise > 0.5, noise, noise.min())  # Устанавливаем значение в минимальное, если шум ниже 0.5
    U = normalize_noise(U)  # Нормализация массива U

    ax.clear()  # Очистка текущего окна

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(U, level=0.5)
    ax.plot_trisurf(verts[:, 0], verts[:, 1], faces, verts[:, 2], color='r', alpha=0.5)

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

for i in range(100):
    update(ax)
    plt.pause(0.1)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Отображение окончательного кадра

[MakarovDs]

теперь я переработал тот код, и теперь могу двигать без лагов:

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np
import noise
from skimage import measure

# Инициализация Pygame
pygame.init()
display = (800, 600)
pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

# Инициализация камеры
gluPerspective(45, (display[0]/display[1]), 0.1, 1000.0)
glTranslatef(0.0, 0.0, -30)
glRotatef(45, 1, 0, 0)  # Повернуть камеру на 45 градусов вокруг оси X

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base, scale):
    noise_array = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise_array[i][j][k] = noise.pnoise3(i/scale,
                                              j/scale,
                                              k/scale,
                                              octaves=octaves,
                                              persistence=persistence,
                                              lacunarity=lacunarity,
                                              repeatx=shape[0],
                                              repeaty=shape[1],
                                              repeatz=shape[2],
                                              base=int(base))
    return normalize_noise(noise_array)

# Создание квантовой пены
def create_foam(base, scale):
    noise_array = generate_noise(base, scale)
    U = np.where(noise_array > 0.5, noise_array, noise_array.min())
    U = normalize_noise(U)
    verts, faces, normals, values = measure.marching_cubes(U, level=0.5)
    return verts, faces

# Отрисовка квантовой пены
def draw_foam(verts, faces):
    glBegin(GL_TRIANGLES)
    for face in faces:
        for vert in face:
            glVertex3fv(verts[vert])
    glEnd()

# Основной цикл
base = 0
scale = 10
x_offset = 0
z_offset = 0
clock = pygame.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                z_offset += 5
            if event.key == pygame.K_s:
                z_offset -= 5
            if event.key == pygame.K_a:
                x_offset -= 5
            if event.key == pygame.K_d:
                x_offset += 5

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glPushMatrix()
    glTranslatef(x_offset, 0, z_offset)
    base += 1
    verts, faces = create_foam(base, scale)
    draw_foam(verts, faces)
    glPopMatrix()
    pygame.display.flip()
    clock.tick(60)

[MakarovDs]

Вот теперь мы можем перемещаться в бесконечно процедурно генерируемой фрактальной пене:

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np
import noise as perlin_noise
from skimage import measure

# Инициализация Pygame
pygame.init()
display = (800, 600)
pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

# Инициализация камеры
gluPerspective(25, (display[0]/display[1]), 0.1, 1000.0)
glTranslatef(-15, 0.0, -150.0)  # Переместить камеру вниз и назад
glRotatef(35, 1, 0, 0)  # Повернуть камеру на 35 градусов вокруг оси X

# Параметры шума Перлина
octaves = 4
persistence = 0.5
lacunarity = 2
scale = 10

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)

# Нормализация шума в диапазон от 0 до 1
def normalize_noise(noise):
    return (noise - noise.min()) / (noise.max() - noise.min())

# Генерация шума Перлина для одного кадра
def generate_noise(base, offset):
    noise = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                noise[i][j][k] = perlin_noise.pnoise3((i + offset[0]) / scale,
                                                     (j + offset[1]) / scale,
                                                     (k + offset[2]) / scale,
                                                     octaves=octaves,
                                                     persistence=persistence,
                                                     lacunarity=lacunarity,
                                                     repeatx=shape[0],
                                                     repeaty=shape[1],
                                                     repeatz=shape[2],
                                                     base=int(base))
    return normalize_noise(noise)

# Функция для обновления кадра
def update(offset):
    base = 42  # Фиксированный base для каждого кадра
    noise = generate_noise(base, offset)
    U = np.where(noise > 0.5, noise, noise.min())  # Устанавливаем значение в минимальное, если шум ниже 0.5
    U = normalize_noise(U)  # Нормализация массива U

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(U, level=0.5)

    # Отрисовка изосурфейса
    glColor4f(0.0, 1.0, 0.0, 0.5)  # Зеленый полупрозрачный цвет
    glEnable(GL_BLEND)  # Включить смешивание цветов
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)  # Установить функцию смешивания
    glBegin(GL_TRIANGLES)
    for face in faces:
        for vertex_index in face:
            vertex = verts[vertex_index]
            glVertex3fv(vertex)
    glEnd()
    glDisable(GL_BLEND)  # Выключить смешивание цветов

# Основной цикл
offset = [0, 0, 0]
clock = pygame.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            quit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                offset[2] += 5
            if event.key == pygame.K_s:
                offset[2] -= 5
            if event.key == pygame.K_a:
                offset[0] -= 5
            if event.key == pygame.K_d:
                offset[0] += 5
            if event.key == pygame.K_q:
                offset[1] -= 5
            if event.key == pygame.K_e:
                offset[1] += 5

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    update(offset)
    pygame.display.flip()
    clock.tick(60)

[MakarovDs]

Ну вот ещё парочку таких странных структур на заметку:

Суперкруглосоты



Ребристые ривы