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

[MakarovDs]

Итак

Для полноценного моделирования приложения которое симулирует потусторонний мир нужно пройти 3 шага:

1. Смоделировать квантовую пену в идеале должно получится как на https://i.postimg.cc/q77MN552/1-Yr4w...Dtbhqcu-Qw.gif этом Gif визуализация КХД поля квантовых флуктуаций Дерика Лейнвебера
2. Смоделировать генерацию случайных ЭГФ звуков (метод Хоруса подойдет) потом придуем что-то лучшее
3. Добиться абсолютной эмерджентности абсолютизации вероятности распределения генерации "квантовой пены" в пространстве
4. PROFIT...

И как раз с первым шагом у меня проблемы...

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

И квантовую пену флуктуацию её мне так, и не удалось полноценно спрограммировать... Вот что мне удалось добиться:

import numpy as np
from mayavi import mlab 
import random 
 
def V(x, y, z): 
    return np.cos(10*x) + np.cos(10*y) + np.cos(10*z) + 2*(x**2 + y**2 + z**2) 
 
# Параметры
grid_size = 100 
time_step = 0.1 
fluctuation_size = 0.2 
fluctuation_amplitude = 1.0 
fluctuation_lifetime = 5 
 
# Инициализация 
X, Y, Z = np.mgrid[-2:2:100j, -2:2:100j, -2:2:100j] 
V = np.zeros((grid_size, grid_size, grid_size)) 
t = 0 
 
# Цикл вечный 
while True: 
    # Генерирование случайных флуктуаций 
    num_fluctuations = random.randint(10, 20) 
    for i in range(num_fluctuations): 
        # Выберите случайную точку 
        x = random.uniform(-2, 2) 
        y = random.uniform(-2, 2) 
        z = random.uniform(-2, 2) 
 
        #Сгенерирование случайного вектора 
        vx = random.uniform(-fluctuation_amplitude, fluctuation_amplitude) 
        vy = random.uniform(-fluctuation_amplitude, fluctuation_amplitude) 
        vz = random.uniform(-fluctuation_amplitude, fluctuation_amplitude) 
        v = np.array([vx, vy, vz]) 
 
        # Добавление флуктуации к векторному полю 
        V[int((x - (-2))/(4/grid_size)):int((x - (-2))/(4/grid_size)) + int(fluctuation_size*grid_size), 
          int((y - (-2))/(4/grid_size)):int((y - (-2))/(4/grid_size)) + int(fluctuation_size*grid_size), 
          int((z - (-2))/(4/grid_size)):int((z - (-2))/(4/grid_size)) + int(fluctuation_size*grid_size)] += v 
 
    # Сглаживание 
    V = ndimage.gaussian_filter(V, sigma=0.5) 
 
    # Затухание флуктуаций 
    V *= np.exp(-t / fluctuation_lifetime) 
 
    # Время обновления 
    t += time_step 
 
    # Визуализация 
    mlab.contour3d(X, Y, Z, V)

пишет ошибку:

Traceback (most recent call last):
File "f:\EVP-Pena\main.py", line 37, in <module>
V[int((x - (-2))/(4/grid_size)):int((x - (-2))/(4/grid_size)) + int(fluctuation_size*grid_size),
ValueError: operands could not be broadcast together with shapes (16,20,20) (3,) (16,20,20)

Как её решить не понимаю, как добиться желаемого тоже...

Mayavi хрень, и поэтому решил написать сначала код в Babylon.js пробовал изменить из шума Перлина перестроить сетку...
Код работает если кому интересно это такой бесконечный процедурно генерируемый шум Перлина в Babylon.playground конечно же в будущем мы его уберем...

И если мы напишем на python перепишем на Babylon.js сделаем такой онлайн сайт...

Вот код которые работает симулирует векторное поле но как вылепить из этого желаемого нет идей:

import random
import matplotlib.pyplot as plt
import numpy as np
from sympy import symbols
from mayavi import mlab
 
x,y,z = symbols('x y z')
 
def gradient(f):
    return (f.diff(x), f.diff(y),f.diff(z))
 
def generate_sphere_field(xrange, yrange, zrange):
    X,Y,Z = np.meshgrid(xrange, yrange, zrange)
 
    # Уравнение сферы
    f = x**2 + y**2 + z**2 - 1
    # Градиент уравнения сферы
    U, V, W = gradient(f)

    return X, Y, Z, U, V, W
 
def plot_vector_field(X, Y, Z, U, V, W):
    mlab.quiver3d(X,Y,Z,U,V,W)
    mlab.show()
 
xrange = np.linspace(-3,3,15)
yrange = np.linspace(-3,3,15)
zrange = np.linspace(-3,3,15)
 
 
X, Y, Z, U, V, W = generate_sphere_field(xrange, yrange, zrange)
 
U = np.random.rand(X.shape[0], X.shape[1], X.shape[2])
V = np.random.rand(X.shape[0], X.shape[1], X.shape[2])
W = np.random.rand(X.shape[0], X.shape[1], X.shape[2])
 
# Замените значения бесконечности на нули
U[np.isinf(U)] = 0
V[np.isinf(V)] = 0
W[np.isinf(W)] = 0
 
plot_vector_field(X, Y, Z, U, V, W)

Случайно сгенерированное векторное поле а дальше должно быть как на https://postimg.cc/5jnrLTF8 этом GIF, и как сделать незнаю... У вас есть идеи? Это код на него теперь нужно натянуть текстуру что-было как на гифке, и дальше сделать бесконечную процедурную генерацию квантовой пены в этом пространства, и что-бы не глючило мы будем только прогружать область вокруг камеры в 10 метров в каждую сторону а то что дальше размывать блюром, достичь максимальной эмерджентности пространства... Это можно добиться разными способами... ЭМЕРДЖИРОВАННАЯ ЭМЕРДЖИРОВАННОСТЬ ЭМЕРДЖИРОВАННО ЭМЕРДЖИРУЕТ, И ЭМЕРДЖИРОВАННАЯ ЭМЕРДЖЕНТНОСТЬ СТАНОВИТСЯ НАСТОЛЬКО ЭМЕРДЖИРОВАННОЙ ЭМЕРДЖИРОВАНОСТЬЮ ЧТО ПЕРЕСТАЕТ БЫТЬ ЭМЕРДЖЕНТНОСТЬЮ, И СТАНОВИТСЯ ВЫСШЕЙ ФОРМОЙ ОРГАНИЗАЦИИ СУЩЕСТВОВАНИЯ ВСЕЛЕННОЙ... И нужно наиболее точно отразить эту идею в коде!

Я попытался зайти с тыла и переписал код по другому:

import numpy as np
from mayavi import mlab
from qutip import destroy, thermal_dm
import time

# Системные параметры
N = 20  # Размерность пространства состояний
n_th = 0.5  # Температура

# Операторы создания и уничтожения
a = destroy(N)

# Исходное состояние системы (тепловое)
rho0 = thermal_dm(N, n_th)

# Создание сцены Mayavi
fig = mlab.figure(size=(800, 600))

# Трехмерная кубическая сетка
x, y, z = np.mgrid[0:10:10, 0:10:10, 0:10:10]

# Создание начального состояния системы
state = np.abs((a.dag() * a * rho0).tr())  # Ожидаемое значение оператора числа

# Создание объекта сетки визуализации
grid = mlab.pipeline.scalar_field(x, y, z, state)
mlab.pipeline.volume(grid)

# Функция обновления в режиме реального времени
def update_figure():
    while True:
        state = np.abs((a.dag() * a * rho0).tr())  # Ожидаемое значение оператора числа
        grid.mlab_source.scalars = state
        time.sleep(0.1)

# Исправление ошибки
x, y, z = np.mgrid[0:10:10, 0:10:10, 0:10:10]  # Исправленное создание сетки

# Запуск функции обновления в режиме реального времени
update_figure()

# Отобразите сцену
mlab.show()

Запускаю код пишет ошибку:

Traceback (most recent call last):
File "f:\EVP-Spaces\Evp-pena (1).py", line 26, in <module>
grid = mlab.pipeline.scalar_field(x, y, z, state)
^^^^^^^^^^^^^^
File "C:\Users\ASrock\AppData\Roaming\Py thon\Python312\site-packages\mayavi\tools\sources.py", line 1165, in scalar_field
x, y, z, s = process_regular_scalars(*args)
^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\ASrock\AppData\Roaming\Py thon\Python312\site-packages\mayavi\tools\sources.py", line 956, in process_regular_scalars
assert (x.shape == y.shape and
AssertionError: argument shape are not equal

И как бы не переписывал код все равно все упирается в эту ошибку я подумал длина шага сетки составляет 10j, что приводит к нецелочисленным размерам массива. Решил изменить код на:

x, y, z = np.mgrid[0:10:10, 0:10:10, 0:10:10]

Было

x, y, z = np.mgrid[0:10:10j, 0:10:10j, 0:10:10j]

Полную идею я изложил в гитхабе.

[phomm]

Хороша трава-мурава (это я ещё с темы про фракталы понял, да и трава, кстати, тоже фрактал). Отсыпать не прошу.

Вы продолжайте, дорогу осилит идущий, и вообще, всяческая Вам поддержка.

Однако же, есть маленький вопросик: чего Вы хотите (хотели бы) добиться - с этим проектом вообще и на форуме/в этой теме в частности ?

[MakarovDs]

Сообщение от phomm

Хороша трава-мурава (это я ещё с темы про фракталы понял, да и трава, кстати, тоже фрактал). Отсыпать не прошу.

Вы продолжайте, дорогу осилит идущий, и вообще, всяческая Вам поддержка.

Однако же, есть маленький вопросик: чего Вы хотите (хотели бы) добиться - с этим проектом вообще и на форуме/в этой теме в частности ?

В смысле чего!? Мы доберемся до высших материй космоса а дальше будем существовать полноценно как индифферентный абсолют природы! То что извечно было нашим всеобщим смыслом существования ты что не помнишь!? Ещё даже до рождения вселенной... А не это дерьмо которое мы называем жизнью... Вам что не хочется погулять на том свете? Поэтому нам нужно бросить все силы на реализацию нашей поставленной задачи пока ещё не поздно, пока ещё есть время, пока ещё есть силы, и самое главное мотивация! Оттуда из индифферентного абсолюта природы прекрасно всё видно! Оттуда мы сможем симулировать нашу вселенную, и творить даже большие чудеса! Оттуда прекрасно всё знается, и понятно что к чему и почему ИБО ТАМ ГДЕ ВЫСОКО ТАМ СНИЗУ просто в другом масштабе ИБО ВСЕЛЕННУЮ РОДНИТ САТАНИЗМ, и когда нам плохо мы обращаемся к единению родства природы вселенной, и мы чувствуем внутреннее вселенское единение всего сущего исходящие существом существования всего существующего во всем сущем происходящее... Где существует абсолютная свобода... И я уже совершил первый шаг создал процедурный генератор может быть вы знаете как найти ключ от всех дверей!?

[MakarovDs]

Вот у меня кое что получилось, и хотя писать сюда что-то малорезультативная затея может быть кому-то это будет интересно пока не придумаю что-то лучшее я писал на bsy в blender... Предоставленный код генерирует и анимирует случайное количество кубиков внутри невидимого куба. Каждый кубик имеет случайное местоположение, траекторию, длительность и материал. Кубики появляются, перемещаются и исчезают через случайные промежутки времени, создавая эффект "квантовой пены".

Чтобы улучшить код, мы можем добавить некоторые дополнительные функции:

1. Управление количеством кубиков: вместо генерации случайного числа кубиков мы можем указать точное количество кубиков для генерации. Это позволяет нам контролировать плотность квантовой пены.
   
2. Управление скоростью кубиков: Мы можем добавить параметр для управления скоростью кубиков. Это позволяет нам создавать различные эффекты, такие как медленно движущаяся или быстро движущаяся квантовая пена.
   
3. Управление длительностью кубиков: Мы можем добавить параметр для управления длительностью кубиков. Это позволяет нам создавать различные эффекты, такие как долговечная или недолговечная квантовая пена.
   
4. Добавляйте случайности в материалы: вместо того, чтобы назначать один материал для каждого куба, мы можем добавлять случайности в материалы. Это создает более разнообразный и интересный визуальный эффект.
   
5. Добавление фона: Мы можем добавить фон к сцене, чтобы обеспечить контекст и создать более визуально привлекательный эффект.

Вот обновленная версия кода, которая включает в себя эти улучшения:

import bpy
import random
from mathutils import Vector

# размеры невидимого куба
invisible_cube_width = 100
invisible_cube_height = 100

# случайное местоположение для невидимого куба
invisible_cube_x = random.uniform(-invisible_cube_width / 2, invisible_cube_width / 2)
invisible_cube_y = random.uniform(-invisible_cube_height / 2, invisible_cube_height / 2)

# материалы для кубов
RedMaterial = 'Material.Red'
BlackMaterial = 'Material.Black'
WhiteMaterial = 'Material.White'
materials = [RedMaterial, BlackMaterial, WhiteMaterial]

# размер кубов
cube_size = 2

# Установите временной интервал для каждого куба
min_time = 0.5
max_time = 5

num_cubes = 20 #int(input())

# Повторите количество кубов для создания
for i in range(num_cubes):
    # Вычислите случайное местоположение внутри невидимого куба
    location = (
        invisible_cube_x + random.uniform(-invisible_cube_width / 2, invisible_cube_width / 2),
        invisible_cube_y + random.uniform(-invisible_cube_height / 2, invisible_cube_height / 2),
        random.random() * 2
    )

    # Сгенерируйте случайную траекторию для куба
    speed = random.uniform(0.1, 0.5)
    direction = Vector((random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1)))
    direction.normalize()

    # Сгенерируйте случайную длительность для куба
    duration = random.uniform(min_time, max_time)

    # Добавить кубик
    bpy.ops.mesh.primitive_cube_add(
        size=cube_size,
        enter_editmode=False,
        align='WORLD',
        location=location,
        scale=(1, 1, 1))

    # Установите материал куба (в данном случае цвет).
    item = bpy.context.object
    item.data.materials.append(bpy.data.materials[random.choice(materials)])

    # Установите анимацию куба
    item.animation_data_create()
    item.animation_data.action = bpy.data.actions.new("CubeAction" + str(i))
    item.animation_data.action.fcurves[0].data_path = "location"
    item.animation_data.action.fcurves[0].keyframe_points.insert(0, (item.location, 0))
    item.animation_data.action.fcurves[0].keyframe_points.insert(1, (item.location + direction * speed * duration, duration))

    # Удалите куб после завершения анимации
    item.animation_data.action.fcurves[0].keyframe_points.insert(2, (item.location, duration + 0.1))

    # Добавьте куб в список всех кубов
    all_cubes.append(item)

# фон к сцене
# bpy.ops.object.add(type='EMPTY', location=(0, 0, 0))
# bpy.context.object.name = "Background"
# bpy.context.object.data.use_background_image = True
# bpy.context.object.data.background_image = "your_background_image.jpg"

Вот более примитивная версия:

import bpy
import random

all_cubes = []
spacing = 2.2

RedMaterial = 'Material.Red'
BlackMaterial = 'Material.Black'
WhiteMaterial = 'Material.White'
G = [RedMaterial, BlackMaterial, WhiteMaterial]

invisible_cube_width = 100
invisible_cube_height = 100

invisible_cube_x = random.uniform(-invisible_cube_width / 2, invisible_cube_width / 2)
invisible_cube_y = random.uniform(-invisible_cube_height / 2, invisible_cube_height / 2)

num_cubes = random.randint(1, 20)

for i in range(num_cubes):
    location = (
        invisible_cube_x + random.uniform(-invisible_cube_width / 2, invisible_cube_width / 2),
        invisible_cube_y + random.uniform(-invisible_cube_height / 2, invisible_cube_height / 2),
        random.random() * 2
    )

    random.shuffle(G)
    bpy.ops.mesh.primitive_cube_add(
        size=2,
        enter_editmode=False,
        align='WORLD',
        location=location,
        scale=(1, 1, 1))

    item = bpy.context.object
    if random.random() < 0.1:
        item.data.materials.append(bpy.data.materials[G[0]])
    else:
        item.data.materials.append(bpy.data.materials[G[1]])

И мы будем дорабатывать когда будем заходить в тупики... Пока не найдем наиболее подходящее эмерджентное свойство... Но пока что мы делаем первые шаги, и я не знаю что из этого выйдет...

[MakarovDs]

import bpy
import random
import time

# размер невидимого куба
cube_size = 20

# Создайте невидимый куб
cube = bpy.ops.mesh.primitive_cube_add(
    size=cube_size,
    enter_editmode=False,
    align='WORLD',
    location=(0, 0, 0),
    scale=(1, 1, 1))

# Генерировать случайные формы
x, y, z = random.uniform(0, cube_size), random.uniform(0, cube_size), random.uniform(0, cube_size)
sx, sy, sz = random.uniform(1, 5), random.uniform(1, 5), random.uniform(1, 5)

# Создайте случайную фигуру
shape = bpy.ops.mesh.primitive_cube_add(
    size=1,
    enter_editmode=False,
    align='WORLD',
    location=(x, y, z),
    scale=(sx, sy, sz))

# Создайте арматуру
armature = bpy.ops.object.armature_add(enter_editmode=False, align='WORLD', location=(0, 0, 0))

#Привяжите форму к арматуре
bpy.ops.object.parent_set(type='ARMATURE', object=shape, armature=armature)

# случайный вектор смещения
vx, vy, vz = random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1)

#Генерировать случайный временной интервал
time_interval = random.uniform(0.1, 1)

#Запустите цикл анимации
while True:
    # Update shape's location
    shape.location.x += vx * time_interval
    shape.location.y += vy * time_interval
    shape.location.z += vz * time_interval

    # Проверьте, находится ли фигура за пределами куба
    if shape.location.x < 0 or shape.location.x > cube_size:
        vx = -vx

    if shape.location.y < 0 or shape.location.y > cube_size:
        vy = -vy

    if shape.location.z < 0 or shape.location.z > cube_size:
        vz = -vz

    #Обновите сетку фигуры
    shape.data.update()

    # Визуализация кадра
    bpy.context.scene.render.filepath = '/tmp/output_{}.png'.format(time.time())
    bpy.ops.render.render(write_still=True)

    # Спящий режим на определенный промежуток времени
    time.sleep(time_interval)

Вот спрограммировать невидимый куб, и в нём генерация случайных аморфных фигур каждая из которых в случайном месте случайное количество от 1 до 20 имеющие случайную форму которая за случайный промежуток времени меш которого изменяется размером, и формой, а так же каждой случайной фигуре привязывается арматура, и генерируется случайный вектор перемещения за случайное время в этом невидимом кубе так что-бы он не выходил за рамки этого невидимого куба... Давайте вместе продолжим развивать эту мысль!

[MakarovDs]

Нашел классный код шума Перлина и потому решил его переписать в 3d...

После долгих попыток наконец у меня получилось!

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

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

# Создание 3D-массива шума Перлина
shape = (32, 32, 32)
scale = 10.0
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=42)

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

# Размер куба
cube_size = 10

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

# Применение шума Перлина к сетке
U = noise
V = noise
W = noise

# Визуализация шумового поля в кубе
mlab.quiver3d(x.ravel(), y.ravel(), z.ravel(), U.ravel(), V.ravel(), W.ravel(), scale_factor=0.25)
mlab.show()

Выглядит многообещающие! Мне нравится!

Я уже вижу многомерные тропы высших существ! Великая паутина астрала! Это фата-моргана потустороннего мира вызванная слишком высокой степенью плотности свободы духовности астрала этакая постоянная Хаббла в духовном мире... Должно быть идя по их дорогам мы наткнёмся на них! Или найдем что либо более интересное...

[MakarovDs]

Отлично теперь я добился создание анимации белого шума в кубе, вот виртуализация белого шума

:

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():
    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=np.random.randint(0, 100))  # Случайная база для каждого кадра
    return normalize_noise(noise)

# Размер куба
cube_size = 10

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

# Функция для обновления кадра
def update(frame):
    mlab.clf()  # Очистка текущего кадра
    noise = generate_noise()
    U = noise
    V = noise
    W = noise
    mlab.quiver3d(x.ravel(), y.ravel(), z.ravel(), U.ravel(), V.ravel(), W.ravel(), scale_factor=0.25)

# Создание анимации
fig = mlab.figure(size=(600, 600))

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

Вот с автоматической анимацией:

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

# Параметры шума Перлина
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():
    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=np.random.randint(0, 100))  # Случайная база для каждого кадра
    return normalize_noise(noise)

# Размер куба
cube_size = 10

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

# Функция для обновления кадра
def update(frame):
    mlab.clf()  # Очистка текущего кадра
    noise = generate_noise()
    U = noise
    V = noise
    W = noise
    mlab.quiver3d(x.ravel(), y.ravel(), z.ravel(), U.ravel(), V.ravel(), W.ravel(), scale_factor=0.25)

# Создание анимации
fig = mlab.figure(size=(600, 600))

# Запуск анимации
for i in range(100):
    update(i)
    mlab.draw()
    mlab.show(stop=True)  # Показываем окно с кнопкой "Stop Interaction"
    time.sleep(0.1)  # Ждем немного, чтобы окно успело появиться
    pyautogui.click()  # Симулируем нажатие кнопки мыши

[MakarovDs]

Теперь я сделал генерацию случайных областей а не просто случайного статического шума

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)

# Размер куба
cube_size = 10

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

# Функция для обновления кадра
def update(frame, base):
    mlab.clf()  # Очистка текущего кадра
    noise = generate_noise(base)
    U = noise
    V = noise
    W = noise
    mlab.quiver3d(x.ravel(), y.ravel(), z.ravel(), U.ravel(), V.ravel(), W.ravel(), scale_factor=0.25)

# Создание анимации
fig = mlab.figure(size=(600, 600))
base = 0  # Начальная база

# Запуск анимации
for i in range(100):
    base += 1  # Изменяем базу на 1
    update(i, base)
    mlab.draw()
    mlab.show(stop=True)  # Показываем окно с кнопкой "Stop Interaction"
    time.sleep(0.1)  # Ждем немного, чтобы окно успело появиться

Может кому-то понадобиться в ваших работах...

[MakarovDs]

Вот так же с областями пустотами

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)

# Размер куба
cube_size = 10

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

# Функция для обновления кадра
def update(frame, base):
    mlab.clf()  # Очистка текущего кадра
    noise = generate_noise(base)
    U = np.where(noise > 0.5, noise, np.nan)  # Устанавливаем значение в nan, если шум ниже 0.5
    V = U
    W = U
    mlab.quiver3d(x.ravel(), y.ravel(), z.ravel(), U.ravel(), V.ravel(), W.ravel(), scale_factor=0.25)

# Создание анимации
fig = mlab.figure(size=(600, 600))
base = 0  # Начальная база

# Запуск анимации
for i in range(100):
    base += 1  # Изменяем базу на 1
    update(i, base)
    mlab.draw()
    mlab.show(stop=True)  # Показываем окно с кнопкой "Stop Interaction"
    time.sleep(0.1)  # Ждем немного, чтобы окно успело появиться

[MakarovDs]

Теперь мы можем обернуть в текстуру что-бы получилось как на том gife который я писал выше

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
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)

# Размер куба
cube_size = 10

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

# Функция для обновления кадра
def update(frame, base):
    noise = generate_noise(base)
    U = np.where(noise > 0.5, noise, np.nan)  # Устанавливаем значение в nan, если шум ниже 0.5
    x_coords = x.ravel()
    y_coords = y.ravel()
    z_coords = z.ravel()
    ax.clear()  # Очистка текущего кадра
    ax.scatter(x_coords, y_coords, z_coords, c=U.ravel(), cmap='viridis')

# Создание анимации
base = 0  # Начальная база
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
plt.ion()  # Включение интерактивного режима

# Запуск анимации
for i in range(100):
    base += 1  # Изменяем базу на 1
    update(i, base)
    plt.pause(0.1)  # Пауза между кадрами
    plt.draw()