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

[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
import random

# Инициализация 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, 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 + 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)

# Чанки и их шум
chunks = {}  # Словарь для хранения шума каждого чанка

# Создание чанка и добавление его в словарь
def create_chunk(offset):
    base = random.randint(0, 1000)  # Случайный base для каждого чанка
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого чанка
    noise = generate_noise(base, offset, scale)
    chunks[tuple(offset)] = noise

# Функция для обновления кадра
def update(offset):
    # Проверить, существует ли шум для текущего чанка
    if tuple(offset) not in chunks:
        create_chunk(offset)  # Создать чанк, если его нет

    noise = chunks[tuple(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)  # Выключить смешивание цветов

# Гиперкуб Хорэдема
def generate_hypercube(offset):
    # Создание 3D-массива случайных чисел
    random_array = np.random.rand(*shape)

    # Определение типа каждой ячейки гиперкуба
    cell_types = np.where(random_array < 0.5, 0, 1)  # 0 - портал, 1 - комната

    # Определение свойств каждой ячейки
    cell_properties = np.random.rand(*shape, 3)  # цвет, размер, форма

    # Создание вершин и граней гиперкуба
    verts = []
    faces = []
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                if cell_types[i][j][k] == 0:  # портал
                    verts.append([i, j, k])
                    faces.append([i, j, k])
                elif cell_types[i][j][k] == 1:  # комната
                    verts.append([i, j, k])
                    faces.append([i, j, k])

    # Отрисовка гиперкуба
    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)
    generate_hypercube(offset)
    pygame.display.flip()
    clock.tick(60)

Осталось только немножко доработать код...

[MakarovDs]

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

import random
import math
import matplotlib.pyplot as plt

# Определение элементов логики
logic_elements = {
    'add': lambda x, y: x + y,
    'ub': lambda x, y: x - y,
    'ul': lambda x, y: x * y,
    'div': lambda x, y: x / y if y!= 0 else 0
}

# Определение объектов логики
logic_objects = {
    'point': lambda x, y: (x, y),
    'line': lambda x1, y1, x2, y2: ((x1, y1), (x2, y2)),
    'circle': lambda x, y, r: (x, y, r)
}

# Определение правил взаимодействия
interaction_rules = {
    'point_line': lambda point, line: point[0] * line[0][0] + point[1] * line[0][1] - line[1][0] * point[0] - line[1][1] * point[1],
    'circle_point': lambda circle, point: math.sqrt((circle[0] - point[0])**2 + (circle[1] - point[1])**2) - circle[2]
}

# Генерация фрактала
def generate_fractal(logic_elements, logic_objects, interaction_rules):
    # Случайный выбор комбинации элементов логики и объектов логики
    logic_element = random.choice(list(logic_elements.keys()))
    logic_object1 = random.choice(list(logic_objects.keys()))
    logic_object2 = random.choice(list(logic_objects.keys()))
    interaction_rule = random.choice(list(interaction_rules.keys()))

    # Генерация фрактала на основе комбинации
    if logic_object1 == 'point':
        obj1 = logic_objects[logic_object1](random.random(), random.random())
    elif logic_object1 == 'line':
        obj1 = logic_objects[logic_object1](random.random(), random.random(), random.random(), random.random())
    elif logic_object1 == 'circle':
        obj1 = logic_objects[logic_object1](random.random(), random.random(), random.random())

    if logic_object2 == 'point':
        obj2 = logic_objects[logic_object2](random.random(), random.random())
    elif logic_object2 == 'line':
        obj2 = logic_objects[logic_object2](random.random(), random.random(), random.random(), random.random())
    elif logic_object2 == 'circle':
        obj2 = logic_objects[logic_object2](random.random(), random.random(), random.random())

    if interaction_rule == 'point_line':
        if logic_object1!= 'point' or logic_object2!= 'line':
            return generate_fractal(logic_elements, logic_objects, interaction_rules)
        result = interaction_rules[interaction_rule](obj1, obj2)
    elif interaction_rule == 'circle_point':
        if logic_object1!= 'circle' or logic_object2!= 'point':
            return generate_fractal(logic_elements, logic_objects, interaction_rules)
        result = interaction_rules[interaction_rule](obj1, obj2)

    return result

# Визуализация фрактала
fractal = [generate_fractal(logic_elements, logic_objects, interaction_rules) for _ in range(100)]
plt.plot(fractal)
plt.show()

[MakarovDs]

И так же для генерации случайных функций с двумя переменными, мы можем использовать библиотеку numpy и функцию random.choice для выбора случайной функции из набора доступных функций.

Для генерации полостей и самоподобия, мы можем использовать технику, называемую "фрактальным генерированием". Она заключается в том, чтобы генерировать фракталы, используя рекурсивные функции, и затем использовать эти фракталы для генерации полостей и самоподобия.

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

# Генерация случайной функции с двумя переменными
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')
for i in range(100):
    x, y, z = generate_space()
    ax.scatter(x, y, z)
plt.show()

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

[MakarovDs]

Вот код который моделирует алгоритм Форчуна для 3-х мерного пространства получилось кастрировано но сейчас мы это исправим...

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np
from scipy.spatial import Voronoi
import random

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

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

# Параметры куба
size = 10

# Генерация точек в кубе
x, y, z = np.mgrid[-size/2:size/2:10j, -size/2:size/2:10j, -size/2:size/2:10j]
points = np.array([x.ravel(), y.ravel(), z.ravel()]).T

# Генерация диаграммы Вороного
vor = Voronoi(points)

# Функция для обновления кадра
def update():
    # Отрисовка граней диаграммы Вороного
    for region in vor.regions:
        if len(region) > 0 and -1 not in region:
            polygon = [vor.vertices[i] for i in region]
            glColor4f(random.random(), random.random(), random.random(), 1.0)  # Случайный цвет
            glBegin(GL_POLYGON)
            for vertex in polygon:
                glVertex3fv(vertex)
            glEnd()

    # Отрисовка точек
    glColor4f(1.0, 1.0, 1.0, 1.0)  # Белый цвет
    glBegin(GL_POINTS)
    for point in points:
        glVertex3fv(point)
    glEnd()

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

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    update()
    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
import random

# Инициализация 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())

# Генерация шума Перлина для всего мира
base_noise = np.zeros(shape)
for i in range(shape[0]):
    for j in range(shape[1]):
        for k in range(shape[2]):
            base_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)  # фиксированный базовый шум

# Генерация уникального шума для каждого чанка
def generate_chunk_noise(offset, 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 + 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)

# Чанки и их шум
chunks = {}  # Словарь для хранения шума каждого чанка

# Создание чанка и добавление его в словарь
def create_chunk(offset):
    base = random.randint(0, 1000)  # Случайный базовый шум для каждого чанка
    chunk_noise = generate_chunk_noise(offset, base)
    chunks[tuple(offset)] = chunk_noise

# Функция для обновления кадра
def update(offset):
    # Проверить, существует ли шум для текущего чанка
    if tuple(offset) not in chunks:
        create_chunk(offset)  # Создать чанк, если его нет

    chunk_noise = chunks[tuple(offset)]  # Получить шум для текущего чанка
    noise = base_noise + chunk_noise  # Сложить базовый шум и шум чанка
    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]

Добавил систему координат:

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
import random

# Инициализация 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, 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 + 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)

# Чанки и их шум
chunks = {}  # Словарь для хранения шума каждого чанка

# Создание чанка и добавление его в словарь
def create_chunk(offset):
    base = random.randint(0, 1000)  # Случайный base для каждого чанка
    scale = random.uniform(1, 10)  # Случайный масштаб для каждого чанка
    noise = generate_noise(base, offset, scale)
    chunks[tuple(offset)] = noise

# Функция для обновления кадра
def update(offset):
    # Проверить, существует ли шум для текущего чанка
    if tuple(offset) not in chunks:
        create_chunk(offset)  # Создать чанк, если его нет

    noise = chunks[tuple(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)  # Выключить смешивание цветов

# Гиперкуб Хорэдема
def generate_hypercube(offset):
    # Создание 3D-массива случайных чисел
    random_array = np.random.rand(*shape)

    # Определение типа каждой ячейки гиперкуба
    cell_types = np.where(random_array < 0.5, 0, 1)  # 0 - портал, 1 - комната

    # Определение свойств каждой ячейки
    cell_properties = np.random.rand(*shape, 3)  # цвет, размер, форма

    # Создание вершин и граней гиперкуба
    verts = []
    faces = []
    for i in range(shape[0]):
        for j in range(shape[1]):
            for k in range(shape[2]):
                if cell_types[i][j][k] == 0:  # портал
                    verts.append([i, j, k])
                    faces.append([i, j, k])
                elif cell_types[i][j][k] == 1:  # комната
                    verts.append([i, j, k])
                    faces.append([i, j, k])

    # Отрисовка гиперкуба
    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()

def draw_text(position, text_string, color):
    font = pygame.font.SysFont("Arial", 20)
    text_surface = font.render(text_string, True, color, (0, 0, 0, 255))
    text_data = pygame.image.tostring(text_surface, 'RGBA', True)
    glRasterPos3d(*position)
    glDrawPixels(text_surface.get_width(), text_surface.get_height(), GL_RGBA, GL_UNSIGNED_BYTE, text_data)

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] += 1
            if event.key == pygame.K_s:
                offset[2] -= 1
            if event.key == pygame.K_a:
                offset[0] -= 1
            if event.key == pygame.K_d:
                offset[0] += 1
            if event.key == pygame.K_q:
                offset[1] -= 1
            if event.key == pygame.K_e:
                offset[1] += 1

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    update(offset)
    generate_hypercube(offset)

    # Отрисовка координат
    draw_text((-23, 32.0, 0), "X: " + str(offset[0]), (255, 255, 255))
    draw_text((-17, 32.0, 0), "Y: " + str(offset[1]), (255, 255, 255))
    draw_text((-11, 32.0, 0), "Z: " + str(offset[2]), (255, 255, 255))

    pygame.display.flip()
    clock.tick(60)

[MakarovDs]

Добавил поля для ввода координат...

https://github.com/MakarovDs777/Quan...coordinates.py



2 дня потратил на то что-бы добавить сраные строки координат, и понял насколько же это парашня сначала попытался сделать окно ткинтер, потом с другого окна pygame, и нечего не получилось только отбил себе все нервы, и в итоге запилил координаты в одно окно.

[Алексей1153]

MakarovDs, а модальных окошек там нет? Это же проще и удобнее