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

[MakarovDs]

Плотность изурфейса

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

# Функция для генерации лабиринта
def generate_maze(shape, direction):
    maze = np.ones(shape, dtype=float)

    def recursive_divide(x, y, z, w, h, d):
        if w < 2 or h < 2 or d < 2:
            return
        if direction == "left_to_right":
            if w > 2:
                wall_x = np.random.randint(x + 1, x + w - 1)
                for i in range(y, y + h):
                    for j in range(z, z + d):
                        maze[wall_x, i, j] = 0.0
                recursive_divide(x, y, z, wall_x - x, h, d)
                recursive_divide(wall_x + 1, y, z, x + w - wall_x - 1, h, d)
        elif direction == "back_to_front":
            if h > 2:
                wall_y = np.random.randint(y + 1, y + h - 1)
                for i in range(x, x + w):
                    for j in range(z, z + d):
                        maze[i, wall_y, j] = 0.0
                recursive_divide(x, y, z, w, wall_y - y, d)
                recursive_divide(x, wall_y + 1, z, w, y + h - wall_y - 1, d)
        elif direction == "top_to_bottom":
            if d > 2:
                wall_z = np.random.randint(z + 1, z + d - 1)
                for i in range(x, x + w):
                    for j in range(y, y + h):
                        maze[i, j, wall_z] = 0.0
                recursive_divide(x, y, z, w, h, wall_z - z)
                recursive_divide(x, y, wall_z + 1, w, h, z + d - wall_z - 1)

    recursive_divide(0, 0, 0, shape[0], shape[1], shape[2])

    return maze

# Параметры
shape = (64, 64, 64)

# Генерация лабиринтов
maze_left_to_right = generate_maze(shape, "left_to_right")
maze_back_to_front = generate_maze(shape, "back_to_front")
maze_top_to_bottom = generate_maze(shape, "top_to_bottom")

# Объединение лабиринтов логическим оператором "и" (AND)
combined_maze = np.logical_and(np.logical_and(maze_left_to_right, maze_back_to_front), maze_top_to_bottom).astype(float)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "combined_maze.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]} {vert[1]} {vert[2]}\n")
    for face in faces:
        f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], faces, verts[:, 2], color='r', alpha=0.5)
plt.show()

[MakarovDs]

Коридоры с острыми углами но коридоры прямые но скрипт для блендера:

import bpy
import bgl
import mathutils
import random

def generate_cube_field(shape):
    points = []
    for _ in range(10):
        x = random.randint(10, shape[0] - 10)
        y = random.randint(10, shape[1] - 10)
        points.append((x, y, shape[2] // 2))

    meshes = []
    for point in points:
        x, y, z = point
        size = random.randint(4, 8)
        bpy.ops.mesh.primitive_cube_add(location=(x, y, z), size=size)
        meshes.append(bpy.context.active_object)

    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        dz = 0
        length = max(abs(dx), abs(dy))
        if abs(dx) > abs(dy):
            for j in range(length):
                new_x = int(points[i][0] + j * dx // length)
                new_y = points[i][1]
                new_z = int(points[i][2])
                size = 2
                bpy.ops.mesh.primitive_cube_add(location=(new_x, new_y, new_z), size=size)
                meshes.append(bpy.context.active_object)
        else:
            for j in range(length):
                new_x = points[i][0]
                new_y = int(points[i][1] + j * dy // length)
                new_z = int(points[i][2])
                size = 2
                bpy.ops.mesh.primitive_cube_add(location=(new_x, new_y, new_z), size=size)
                meshes.append(bpy.context.active_object)

    # Объединяем все меши в один
    bpy.ops.object.select_all(action='DESELECT')
    for mesh in meshes:
        mesh.select_set(True)
    bpy.ops.object.join()

    # Делаем конструкцию полой внутри
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.remove_doubles(threshold=0.01)
    bpy.ops.mesh.delete_loose()
    bpy.ops.object.mode_set(mode='OBJECT')

    # Делаем конструкцию полой внутри
    bpy.ops.object.modifier_add(type='SOLIDIFY')
    bpy.context.object.modifiers['Solidify'].thickness = -1

def main():
    shape = (128, 128, 128)
    generate_cube_field(shape)

if __name__ == "__main__":
    main()

[MakarovDs]

Коридоры с острыми углами но коридоры прямые:

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

def generate_cube_field(shape):
    points = []
    for _ in range(10):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        points.append([x, y, shape[2] // 2])

    meshes = []
    for point in points:
        x, y, z = point
        size = np.random.randint(4, 8)
        box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([x, y, z]))
        meshes.append(box)

    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        dz = 0
        length = max(abs(dx), abs(dy))
        if abs(dx) > abs(dy):
            for j in range(length):
                new_x = int(points[i][0] + j * dx // length)
                new_y = points[i][1]
                new_z = int(points[i][2])
                size = 2
                box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([new_x, new_y, new_z]))
                meshes.append(box)
        else:
            for j in range(length):
                new_x = points[i][0]
                new_y = int(points[i][1] + j * dy // length)
                new_z = int(points[i][2])
                size = 2
                box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([new_x, new_y, new_z]))
                meshes.append(box)

    mesh = trimesh.util.concatenate(meshes)
    return mesh

shape = (128, 128, 128)
cube_field = generate_cube_field(shape)

desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "cube.obj")
cube_field.export(filename)
print(f"Model saved as {filename}")

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(cube_field.vertices[:, 0], cube_field.vertices[:, 1], cube_field.vertices[:, 2], color='r', alpha=0.5)
for face in cube_field.faces:
    v1, v2, v3 = cube_field.vertices[face]
    ax.plot3D([v1[0], v2[0]], [v1[1], v2[1]], [v1[2], v2[2]], 'r', alpha=0.5)
    ax.plot3D([v2[0], v3[0]], [v2[1], v3[1]], [v2[2], v3[2]], 'r', alpha=0.5)
    ax.plot3D([v3[0], v1[0]], [v3[1], v1[1]], [v3[2], v1[2]], 'r', alpha=0.5)
plt.show()

[MakarovDs]

Коридоры без комнат но это кубические коридоры

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

def generate_corridor_field(shape, num_points=10):
    points = []
    for _ in range(num_points):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        z = shape[2] // 2
        points.append([x, y, z])

    meshes = []
    for i in range(len(points) - 1):
        start_point = points[i]
        end_point = points[i + 1]
        start_x, start_y, start_z = start_point
        end_x, end_y, end_z = end_point

        length = max(abs(end_x - start_x), abs(end_y - start_y))
        if length == 0:
            continue

        for j in range(length + 1):
            new_x = start_x + j * (end_x - start_x) // length
            new_y = start_y + j * (end_y - start_y) // length
            new_z = start_z
            size = 2
            box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([new_x, new_y, new_z]))
            meshes.append(box)

    mesh = trimesh.util.concatenate(meshes)
    return mesh

shape = (128, 128, 128)
corridor_field = generate_corridor_field(shape)

desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "corridor.obj")
corridor_field.export(filename)
print(f"Model saved as {filename}")

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(corridor_field.vertices[:, 0], corridor_field.vertices[:, 1], corridor_field.vertices[:, 2], color='r', alpha=0.5)
for face in corridor_field.faces:
    v1, v2, v3 = corridor_field.vertices[face]
    ax.plot3D([v1[0], v2[0]], [v1[1], v2[1]], [v1[2], v2[2]], 'r', alpha=0.5)
    ax.plot3D([v2[0], v3[0]], [v2[1], v3[1]], [v2[2], v3[2]], 'r', alpha=0.5)
    ax.plot3D([v3[0], v1[0]], [v3[1], v1[1]], [v3[2], v1[2]], 'r', alpha=0.5)
plt.show()

[MakarovDs]

Процедурный генератор дорожек

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

# Функция для генерации 3D-поля с коридорами
def generate_delaunay_field(shape):
    array = np.zeros(shape, dtype=float)

    # Генерация точек для коридоров
    points = []
    for _ in range(10):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        points.append([x, y, shape[2] // 2])  # Генерируем точки на фиксированной высоте

    # Генерация коридоров между точками
    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        length = max(abs(dx), abs(dy))
        if abs(dx) > abs(dy):
            for j in range(length):
                new_x = int(points[i][0] + j * dx // length)
                new_y = points[i][1]
                new_z = int(points[i][2])
                for k in range(-2, 3):
                    for l in range(-2, 3):
                        x1, y1, z1 = new_x + k, new_y + l, new_z
                        if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                            array[x1, y1, z1] = 1.0
        else:
            for j in range(length):
                new_x = points[i][0]
                new_y = int(points[i][1] + j * dy // length)
                new_z = int(points[i][2])
                for k in range(-2, 3):
                    for l in range(-2, 3):
                        x1, y1, z1 = new_x + k, new_y + l, new_z
                        if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                            array[x1, y1, z1] = 1.0

    return array

# Параметры
shape = (128, 128, 128)  # Размеры 3D массива

# Генерация 3D-поля с коридорами
delaunay_field = generate_delaunay_field(shape)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "delaunay.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]} {vert[1]} {vert[2]}\n")
    for face in faces:
        f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], color='r', alpha=0.5)
plt.show()

[MakarovDs]

Процедурный генератор сланцев

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

# Функция для генерации 3D-поля с коридорами
def generate_delaunay_field(shape):
    array = np.zeros(shape, dtype=float)

    # Генерация точек для коридоров
    points = []
    for _ in range(10):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        points.append([x, y, shape[2] // 2])  # Генерируем точки на фиксированной высоте

    # Генерация коридоров между точками
    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        length = int(np.sqrt(dx**2 + dy**2))
        
        for j in range(length):
            new_x = int(points[i][0] + j * dx // length)
            new_y = int(points[i][1] + j * dy // length)
            new_z = int(points[i][2] + np.random.randint(-3, 4))  # Варьируем высоту

            # Делаем коридоры более жирными
            for k in range(-3, 4):
                for l in range(-3, 4):
                    x1, y1, z1 = new_x + k, new_y + l, new_z
                    if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                        array[x1, y1, z1] = 1.0

    return array

# Параметры
shape = (128, 128, 128)  # Размеры 3D массива

# Генерация 3D-поля с коридорами
delaunay_field = generate_delaunay_field(shape)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "delaunay.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]} {vert[1]} {vert[2]}\n")
    for face in faces:
        f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], color='r', alpha=0.5)
plt.show()

[MakarovDs]

Коридоры бэкрумс острые но без комнат.

import numpy as np
import trimesh
import matplotlib.pyplot as plt
import os

# Функция для генерации 3D-поля с ровными коридорами
def generate_delaunay_field(shape):
    points = []
    for _ in range(10):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        points.append([x, y, shape[2] // 2])  # Генерация точек на фиксированной высоте

    meshes = []

    # Создание кубов на фиксированной высоте
    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        length = max(abs(dx), abs(dy))

        if abs(dx) > abs(dy):
            for j in range(length + 1):
                new_x = int(points[i][0] + j * dx // length)
                new_y = points[i][1]
                new_z = int(points[i][2])
                size = 2
                box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([new_x, new_y, new_z]))
                meshes.append(box)
        else:
            for j in range(length + 1):
                new_x = points[i][0]
                new_y = int(points[i][1] + j * dy // length)
                new_z = int(points[i][2])
                size = 2
                box = trimesh.primitives.Box(extents=(size, size, size), transform=trimesh.transformations.translation_matrix([new_x, new_y, new_z]))
                meshes.append(box)

    # Объединение всех кубов в одну сетку
    mesh = trimesh.util.concatenate(meshes)
    return mesh

# Параметры
shape = (128, 128, 128)

# Генерация 3D-поля с коридорами
delaunay_field = generate_delaunay_field(shape)

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "delaunay.obj")
delaunay_field.export(filename)
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(delaunay_field.vertices[:, 0], delaunay_field.vertices[:, 1], delaunay_field.vertices[:, 2], color='r', alpha=0.5)
for face in delaunay_field.faces:
    v1, v2, v3 = delaunay_field.vertices[face]
    ax.plot3D([v1[0], v2[0]], [v1[1], v2[1]], [v1[2], v2[2]], 'r', alpha=0.5)
    ax.plot3D([v2[0], v3[0]], [v2[1], v3[1]], [v2[2], v3[2]], 'r', alpha=0.5)
    ax.plot3D([v3[0], v1[0]], [v3[1], v1[1]], [v3[2], v1[2]], 'r', alpha=0.5)
plt.show()

[MakarovDs]

Процедурный генератор Synthwave поверхности

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

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

# Генерация шума
def generate_noise_2d(shape, x_offset, z_offset, scale=100.0, octaves=6, persistence=0.5, lacunarity=2.0):
    noise_map = np.zeros(shape)
    for i in range(shape[0]):
        for j in range(shape[1]):
            noise_map[i][j] = noise.pnoise2((i + x_offset) / scale, (j + z_offset) / scale, octaves=octaves,
                                              persistence=persistence, lacunarity=lacunarity, repeatx=1024,
                                              repeaty=1024, base=42)
    return noise_map

# Создание террейна
def create_terrain(width, height, x_offset, z_offset):
    noise_map = generate_noise_2d((width, height), x_offset, z_offset)
    vertices = []
    for i in range(width):
        for j in range(height):
            x = i - width // 2
            z = j - height // 2
            y = noise_map[i][j] * 10
            vertices.append((x, y, z))
    return vertices

# Отрисовка террейна
def draw_terrain(vertices, width, height):
    glBegin(GL_LINES)
    for i in range(width):
        for j in range(height):
            if i < width - 1:
                glVertex3fv(vertices[i * height + j])
                glVertex3fv(vertices[(i + 1) * height + j])
            if j < height - 1:
                glVertex3fv(vertices[i * height + j])
                glVertex3fv(vertices[i * height + j + 1])
    glEnd()

# Сохранение в OBJ файл
def save_to_obj(vertices, filename):
    with open(filename, "w") as f:
        for v in vertices:
            f.write(f"v {v[0]} {v[1]} {v[2]}\n")
        for i in range(len(vertices) - 1):
            if (i + 1) % 20 != 0:  # Не соединять последнюю точку в строке
                f.write(f"l {i + 1} {i + 2}\n")
            if i < len(vertices)-20:  # Не выходит за границы
                f.write(f"l {i + 1} {i + 20 + 1}\n")

# Основной цикл
width, height = 20, 20
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
            if event.key == pygame.K_r:  # Сохранение на нажатие R
                desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
                filename = os.path.join(desktop_path, "terrain_chunk.obj")
                save_to_obj(create_terrain(width, height, x_offset, z_offset), filename)
                print(f"Model saved as {filename}")

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    vertices = create_terrain(width, height, x_offset, z_offset)
    draw_terrain(vertices, width, height)
    pygame.display.flip()
    clock.tick(60)

[MakarovDs]

Процедурный генератор кривых дорожек

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

# Функция для генерации 3D-поля с трубками
def generate_tube_field(shape, tube_radius):
    array = np.zeros(shape, dtype=float)

    # Генерация точек для трубок
    points = []
    for _ in range(10):
        x = np.random.randint(tube_radius, shape[0] - tube_radius)
        y = np.random.randint(tube_radius, shape[1] - tube_radius)
        points.append([x, y, shape[2] // 2])  # Генерируем точки на фиксированной высоте

    # Генерация трубок между точками
    for i in range(len(points) - 1):
        dx = points[i + 1][0] - points[i][0]
        dy = points[i + 1][1] - points[i][1]
        length = int(np.sqrt(dx**2 + dy**2))
        
        for j in range(length + 1):  # Проход по всей длине трубки
            # Прямое смещение до следующей точки
            new_x = int(points[i][0] + j * dx // length)
            new_y = int(points[i][1] + j * dy // length)
            new_z = int(points[i][2])

            # Создание поперечного сечения трубки
            for k in range(-tube_radius, tube_radius + 1):
                for l in range(-tube_radius, tube_radius + 1):
                    if k**2 + l**2 <= tube_radius**2:  # Убедиться, что мы находимся в пределах радиуса трубки
                        x1, y1, z1 = new_x + k, new_y + l, new_z
                        if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                            array[x1, y1, z1] = 1.0

    return array

# Параметры
shape = (128, 128, 128)  # Размеры 3D массива
tube_radius = 3          # Радиус трубки

# Генерация 3D-поля с трубками
delaunay_field = generate_tube_field(shape, tube_radius)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "tubes.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]:.4f} {vert[1]:.4f} {vert[2]:.4f}\n")
    for face in faces:
        f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], color='r', alpha=0.5)
plt.show()

[MakarovDs]

Генератор бэкрумс только это вздутые пещеры

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

# Функция для генерации 3D-поля с коридорами
def generate_delaunay_field(shape):
    array = np.zeros(shape, dtype=float)

    # Генерация точек для коридоров
    points = []
    for _ in range(10):
        x = np.random.randint(10, shape[0] - 10)
        y = np.random.randint(10, shape[1] - 10)
        points.append([x, y, shape[2] // 2])  # Генерация точек на фиксированной высоте

    # Генерация коридоров между точками
    radius = 10  # Радиус вздутия
    for i in range(len(points) - 1):
        x1, y1, z1 = points[i]
        x2, y2, z2 = points[i + 1]
        
        # Линейная интерполяция между точками
        for t in np.linspace(0, 1, num=10):
            x = int(x1 + (x2 - x1) * t)
            y = int(y1 + (y2 - y1) * t)
            z = z1  # Поддерживаем фиксированную высоту
            for dx in range(-radius, radius + 1):
                for dy in range(-radius, radius + 1):
                    for dz in range(-radius, radius + 1):
                        if dx**2 + dy**2 + dz**2 <= radius**2:  # Проверка на попадание в сферу
                            if 0 <= x + dx < shape[0] and 0 <= y + dy < shape[1] and 0 <= z + dz < shape[2]:
                                array[x + dx, y + dy, z + dz] = 1.0

    return array

# Параметры
shape = (128, 128, 128)  # Размеры 3D массива

# Генерация 3D-поля с коридорами
delaunay_field = generate_delaunay_field(shape)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "delaunay.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]:.4f} {vert[1]:.4f} {vert[2]:.4f}\n")
    for face in faces:
        f.write(f"f {face[0] + 1} {face[1] + 1} {face[2] + 1}\n")
print(f"Model saved as {filename}")

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], color='r', alpha=0.5)
plt.show()