Эксперименты с генератором фракталов

[MakarovDs]

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

На шейдертои есть куча примеров реализации фракталов можно подсмотреть
https://www.shadertoy.com/results?query=Fractal

Да хрень все эти фракталы... Вот когда я смогу процедурно сгенерировать головы как у Алекса Грея на картинке как на первой странице, и кстати я смог смоделировать в блендере с помощью аддона кентолса вот модель зацените вот тогда поговорим а так это фигня полная эти фракталы...

[MakarovDs]

Астероиды

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 = 6
persistence = 0.5
lacunarity = 2.0

# Создание 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 apply_ridging(noise):
    noise_a = generate_noise(random.randint(0, 1000), random.uniform(1, 10))
    noise_b = generate_noise(random.randint(0, 1000), random.uniform(1, 10))
    return np.abs(noise_a) + np.abs(noise_b)

# Функция для создания спагетти-шума
def create_noodle_noise(noise):
    noise = np.abs(noise)
    noise = np.where(noise < 0.5, 0, noise)
    noise = np.where(noise > 0.7, 1, noise)
    return noise

# Функция для обновления кадра
def update(ax):
    base = random.randint(0, 1000)  # Случайный base для каждого кадра
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого кадра
    noise = generate_noise(base, scale)
    noise = apply_ridging(noise)  # Применение риджинга
    noise = create_noodle_noise(noise)  # Создание спагетти-шума
    noise = normalize_noise(noise)  # Нормализация массива

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

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(noise, 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()  # Отображение окончательного кадра

И вторая версия с микрометеоритами:

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 = 6
persistence = 0.5
lacunarity = 2.0

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

# Нормализация шума в диапазон от 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 create_noodle_noise(noise):
    noise = np.abs(noise)
    noise = np.where(noise < 0.8, 0, noise)
    noise = np.where(noise > 0.9, 1, noise)
    return noise

# Функция для обновления кадра
def update(ax):
    base = random.randint(0, 1000)  # Случайный base для каждого кадра
    scale = random.uniform(5, 10)  # Случайный масштаб для каждого кадра
    noise = generate_noise(base, scale)
    noise = create_noodle_noise(noise)  # Создание спагетти-шума
    noise = normalize_noise(noise)  # Нормализация массива

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

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(noise, 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 numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.spatial import Delaunay
import time
import random

class AmorphousFigure:
    def __init__(self, x, y, z, vx, vy, vz, num_vertices):
        self.x = x
        self.y = y
        self.z = z
        self.vx = vx
        self.vy = vy
        self.vz = vz
        self.num_vertices = num_vertices
        self.vertices = self.generate_vertices()

    def generate_vertices(self):
        vertices = np.random.rand(self.num_vertices, 3) * 10 - 5
        vertices += np.array([self.x, self.y, self.z])
        return vertices

    def update(self):
        self.x += self.vx
        self.y += self.vy
        self.z += self.vz

        if self.x < 0 or self.x > 100:
            self.vx *= -1
        if self.y < 0 or self.y > 100:
            self.vy *= -1
        if self.z < 0 or self.z > 100:
            self.vz *= -1

        self.vertices = self.generate_vertices()

    def get_vertices(self):
        return self.vertices

class LavaLamp:
    def __init__(self, num_figures):
        self.num_figures = num_figures
        self.figures = []
        self.size_factors = [10, 20, 30, 40, 50]
        self.probabilities = [0.4, 0.3, 0.2, 0.08, 0.02]

        for i in range(num_figures):
            x = np.random.uniform(0, 100)
            y = np.random.uniform(0, 100)
            z = np.random.uniform(0, 100)
            vx = np.random.uniform(-1, 1)
            vy = np.random.uniform(-1, 1)
            vz = np.random.uniform(-1, 1)

            size_factor = np.random.choice(self.size_factors, p=self.probabilities)
            num_vertices = size_factor

            self.figures.append(AmorphousFigure(x, y, z, vx, vy, vz, num_vertices))

    def update(self):
        for figure in self.figures:
            figure.update()

    def get_vertices(self):
        vertices = []

        for figure in self.figures:
            vertices.append(figure.get_vertices())

        return vertices

def main():
    num_figures = 10
    lamp = LavaLamp(num_figures)

    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    for i in range(100):
        lamp.update()
        vertices = lamp.get_vertices()

        ax.clear()
        ax.set_xlim(0, 100)
        ax.set_ylim(0, 100)
        ax.set_zlim(0, 100)

        for i, v in enumerate(vertices):
            ax.scatter(v[:, 0], v[:, 1], v[:, 2], c='r', marker='o', s=10)

            tri = Delaunay(v)
            ax.plot_trisurf(v[:, 0], v[:, 1], v[:, 2], triangles=tri.simplices, color='r', alpha=0.5)

        plt.pause(0.01)

    plt.show()

if __name__ == "__main__":
    main()

[MakarovDs]

Вообщем никак у меня не получается симулировать Noodle лапшу как в майнкрафте... Получились опять микрометеориты но зато на этот раз получилось без глюков как в том 52 комментарии где были огромные столбы изурфейсов.

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

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

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

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

# Генерация шума Noodle для одного кадра
def generate_noodle_noise(shape, 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] = np.abs(np.random.normal(0, 1, 1)) + np.abs(np.random.normal(0, 1, 1))
    return normalize_noise(noise)

# Функция для риджинга шума
def ridge_noise(noise):
    return np.where(noise > 0.5, noise, noise)

# Функция для генерации кадра
def update(ax):
    scale = random.uniform(1, 10)  # Случайный масштаб для кадра
    noise = generate_noodle_noise((32, 32, 32), scale)
    noise = ridge_noise(noise)
    U = np.where(noise > 0.5, noise, noise)
    U = normalize_noise(U)

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

    # Создание изосурфейса
    verts, faces, normals, values = measure.marching_cubes(U, 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(10)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

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

[MakarovDs]

Щас мы это исправим

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

# Генерация случайной функции с двумя переменными
def generate_function():
    functions = [lambda x, y: x + y, lambda x, y: x - y, lambda x, y: x * y, lambda x, y: x / y]
    return random.choice(functions)

# Генерация фрактала
def generate_fractal(x, y, z, depth):
    if depth == 0:
        return np.array([x, y, z])
    else:
        x1 = x + np.random.uniform(-1, 1)
        y1 = y + np.random.uniform(-1, 1)
        z1 = z + np.random.uniform(-1, 1)
        return np.array([x1, y1, z1]) + generate_fractal(x1, y1, z1, depth - 1)

# Генерация полостей и самоподобия
def generate_cavity(x, y, z, depth):
    if depth == 0:
        return np.array([x, y, z])
    else:
        x1 = x + np.random.uniform(-1, 1)
        y1 = y + np.random.uniform(-1, 1)
        z1 = z + np.random.uniform(-1, 1)
        return np.array([x1, y1, z1]) + generate_cavity(x1, y1, z1, depth - 1)

# Генерация трехмерного пространства
def generate_space():
    x = np.random.uniform(-10, 10)
    y = np.random.uniform(-10, 10)
    z = np.random.uniform(-10, 10)
    depth = np.random.randint(1, 10)
    return generate_fractal(x, y, z, depth)

# Визуализация пространства
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

points = []
for i in range(100):
    x, y, z = generate_space()
    points.append([x, y, z])

for i in range(len(points) - 1):
    ax.plot([points[i][0], points[i+1][0]], [points[i][1], points[i+1][1]], [points[i][2], points[i+1][2]], 'b-')

ax.scatter(*zip(*points))
plt.show()

[MakarovDs]

Чёт ни то

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

# Генерация случайной функции с двумя переменными
def generate_function():
    functions = [lambda x, y: x + y, lambda x, y: x - y, lambda x, y: x * y, lambda x, y: x / y]
    return random.choice(functions)

# Генерация трехмерного массива данных
def generate_data():
    x = np.linspace(-10, 10, 100)
    y = np.linspace(-10, 10, 100)
    X, Y = np.meshgrid(x, y)
    Z = np.zeros((100, 100))

    func = generate_function()
    for i in range(100):
        for j in range(100):
            Z[i, j] = func(X[i, j], Y[i, j])

    return X, Y, Z

# Визуализация изосурфейса
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

X, Y, Z = generate_data()
verts, faces, normals, values = np.zeros((100, 100, 3)), np.zeros((100, 100, 3)), np.zeros((100, 100, 3)), np.zeros((100, 100))

for i in range(100):
    for j in range(100):
        verts[i, j, 0] = X[i, j]
        verts[i, j, 1] = Y[i, j]
        verts[i, j, 2] = Z[i, j]

ax.plot_trisurf(verts[:, :, 0].flatten(), verts[:, :, 1].flatten(), faces.flatten(), verts[:, :, 2].flatten(), color='r', alpha=0.5)

plt.show()

[MakarovDs]

УЖЕ ЛУЧШЕ

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

# Функция для генерации кадра
def update(ax):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for i in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    for i in range(len(points) - 1):
        ax.plot([points[i][0], points[i+1][0]], [points[i][1], points[i+1][1]], [points[i][2], points[i+1][2]], 'b-', linewidth=5)

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

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

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

[MakarovDs]

Короче поискал в сети нашел алгоритм Триангуляции Делоне, и вот что у меня получилось:

import numpy as np
import matplotlib.pyplot as plt
import random
from mpl_toolkits.mplot3d import Axes3D
from scipy.spatial import Delaunay

# Генерация случайной функции с двумя переменными
def generate_function():
    functions = [lambda x, y: x + y, lambda x, y: x - y, lambda x, y: x * y, lambda x, y: x / y]
    return random.choice(functions)

# Генерация фрактала
def generate_fractal(x, y, z, depth):
    if depth == 0:
        return np.array([x, y, z])
    else:
        x1 = x + np.random.uniform(-1, 1)
        y1 = y + np.random.uniform(-1, 1)
        z1 = z + np.random.uniform(-1, 1)
        return np.array([x1, y1, z1]) + generate_fractal(x1, y1, z1, depth - 1)

# Генерация полостей и самоподобия
def generate_cavity(x, y, z, depth):
    if depth == 0:
        return np.array([x, y, z])
    else:
        x1 = x + np.random.uniform(-1, 1)
        y1 = y + np.random.uniform(-1, 1)
        z1 = z + np.random.uniform(-1, 1)
        return np.array([x1, y1, z1]) + generate_cavity(x1, y1, z1, depth - 1)

# Генерация трехмерного пространства
def generate_space():
    x = np.random.uniform(-10, 10)
    y = np.random.uniform(-10, 10)
    z = np.random.uniform(-10, 10)
    depth = np.random.randint(1, 10)
    return generate_fractal(x, y, z, depth)

# Визуализация пространства
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Создание трехмерных точек
points = np.zeros((100, 3))
for i in range(100):
    x, y, z = generate_space()
    points[i, :] = [x, y, z]

# Выполнить триангуляцию Делоне
triangulation = Delaunay(points)

# Нарисуйте точки и треугольники
ax.scatter(points[:, 0], points[:, 1], points[:, 2])
for triangle in triangulation.simplices:
    ax.plot3D(points[triangle, 0], points[triangle, 1], points[triangle, 2], 'k-')

plt.show()

[MakarovDs]

А теперь созданный изурфейсом без шаров и линий:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import time
import random
from scipy.spatial import Delaunay

# Функция для генерации кадра
def update(ax):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for i in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    # Преобразование точек в NumPy массив 
    points = np.array(points)

    # Выполнить триангуляцию Делоне
    triangulation = Delaunay(points)

    # Постройте график треугольников
    for triangle in triangulation.simplices:
        ax.plot3D(points[triangle, 0], points[triangle, 1], points[triangle, 2], 'k-', linewidth=5)

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

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

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

[MakarovDs]

Хотел посмотреть модель в блендере но получился камень а не то что ожидалось, ну может быть кому-то понадобиться? Вот код:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import random
import os
from scipy.spatial import Delaunay
import atexit

def draw_delaunay(points, axis):
    # Выполнить триангуляцию Делоне
    triangulation = Delaunay(points)
    for triangle in triangulation.simplices:
        axis.plot3D(points[triangle, 0], points[triangle, 1], points[triangle, 2], 'k-', linewidth=5)

def save_obj(vertices, faces, filename):
    with open(filename, 'w') as f:
        for vertex in vertices:
            f.write(f"v {vertex[0]} {vertex[1]} {vertex[2]}\n")
        for face in faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")

def on_exit():
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop", "delaunay.obj")
    save_obj(points, triangulation.simplices, desktop_path)
    print(f"OBJ файл сохранен на рабочем столе как 'delaunay.obj'")

# Создаем фигуру и ось для 3D отображения
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Списки для хранения точек и граней
points = []
faces = []

# Начальные параметры
for i in range(100):
    x = np.random.uniform(-100, 100)
    y = np.random.uniform(-100, 100)
    z = np.random.uniform(-100, 100)
    points.append([x, y, z])

# Вызываем функцию для рисования триангуляции Делоне
points = np.array(points)
triangulation = Delaunay(points)
draw_delaunay(points, ax)

# Подключаем обработчик события
atexit.register(on_exit)

# Показываем график
plt.show()