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

[MakarovDs]

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

def generate_cube_field(shape, dent_size=0.2, dent_depth=0.1):
    array = np.ones(shape, dtype=float)

    # Создаем вмятины на поверхности куба
    for x in range(shape[0]):
        for y in range(shape[1]):
            for z in range(shape[2]):
                # Преобразуем координаты в диапазон (-1, 1)
                xf = (x / shape[0]) * 2 - 1
                yf = (y / shape[1]) * 2 - 1
                zf = (z / shape[2]) * 2 - 1

                # Проверяем расстояние от поверхности куба для вмятин
                dent_distance_x = abs(xf - 0.5) - dent_size
                dent_distance_y = abs(yf - 0.5) - dent_size
                dent_distance_z = abs(zf - 0.5) - dent_size

                # Вычисляем значение куба с вмятинами
                if (dent_distance_x < 0 or dent_distance_y < 0 or dent_distance_z < 0):
                    array[x, y, z] = 1 - dent_depth
                elif (abs(xf) > 0.5 or abs(yf) > 0.5 or abs(zf) > 0.5):
                    array[x, y, z] = 0.0
    return array

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

# Генерация 3D-поля
cube_field = generate_cube_field(shape)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "cube_dent.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 numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import measure
import os

def generate_labyrinth(shape, wall_density, wall_height):
    # Создаем 3D массив для лабиринта
    labyrinth = np.zeros(shape, dtype=bool)

    # Генерируем стены лабиринта
    for x in range(shape[0]):
        for y in range(shape[1]):
            if np.random.rand() < wall_density:
                for z in range(wall_height):
                    labyrinth[x, y, z] = True

    # Создаем сквозные проходы через потолок и пол
    for x in range(shape[0]):
        for y in range(shape[1]):
            if labyrinth[x, y, 0]:
                for z in range(1, wall_height):
                    labyrinth[x, y, z] = False
            if labyrinth[x, y, shape[2] - 1]:
                for z in range(shape[2] - 2, 0, -1):
                    labyrinth[x, y, z] = False

    return labyrinth

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
wall_density = 0.1  # Плотность стен
wall_height = 10  # Высота стен

# Генерация лабиринта
labyrinth = generate_labyrinth(shape, wall_density, wall_height)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "labyrinth.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 numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import measure
import os

def generate_hair_surface(shape, hair_length, hair_density):
    # Создаем 3D массив для поверхности
    surface = np.zeros(shape, dtype=float)

    # Генерируем волосы на поверхности
    for x in range(shape[0]):
        for y in range(shape[1]):
            if np.random.rand() < hair_density:
                hair_x = x
                hair_y = y
                hair_z = 0
                for z in range(hair_length):
                    surface[hair_x, hair_y, z] = 1.0
                    # Делаем волосы более жирными
                    if hair_x > 0:
                        surface[hair_x-1, hair_y, z] = 1.0
                    if hair_x < shape[0] - 1:
                        surface[hair_x+1, hair_y, z] = 1.0
                    if hair_y > 0:
                        surface[hair_x, hair_y-1, z] = 1.0
                    if hair_y < shape[1] - 1:
                        surface[hair_x, hair_y+1, z] = 1.0

    return surface

def generate_plane_surface(shape, plane_z):
    # Создаем 3D массив для поверхности
    surface = np.zeros(shape, dtype=float)

    # Генерируем плоскость на заданной высоте
    for x in range(shape[0]):
        for y in range(shape[1]):
            surface[x, y, plane_z] = 1.0
            # Делаем плоскость более жирной
            if plane_z > 0:
                surface[x, y, plane_z-1] = 1.0
            if plane_z < shape[2] - 1:
                surface[x, y, plane_z+1] = 1.0

    return surface

def generate_holes(surface, hole_probability, hole_size):
    # Генерируем дырки в поверхности
    for x in range(surface.shape[0]):
        for y in range(surface.shape[1]):
            if np.random.rand() < hole_probability:
                hole_x = x
                hole_y = y
                for i in range(-hole_size, hole_size+1):
                    for j in range(-hole_size, hole_size+1):
                        if 0 <= hole_x + i < surface.shape[0] and 0 <= hole_y + j < surface.shape[1]:
                            surface[hole_x + i, hole_y + j, :] = 0.0

    return surface

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
hair_length = 10  # Длина волос
hair_density = 0.1  # Плотность волос
plane_z = 0  # Высота плоскости
hole_probability = 0.05  # Вероятность появления дырки
hole_size = 2  # Размер дырки

# Генерация поверхности с волосами
hair_surface = generate_hair_surface(shape, hair_length, hair_density)

# Генерация плоскости под волосами
plane_surface = generate_plane_surface(shape, plane_z)

# Объединение поверхностей логическим оператором "или"
surface = np.logical_or(hair_surface, plane_surface).astype(float)

# Генерация дырок в поверхности
surface = generate_holes(surface, hole_probability, hole_size)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "lines.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 numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import measure
import os

def generate_maze(shape, wall_density):
    # Создаем 3D массив для лабиринта
    maze = np.ones(shape, dtype=float)

    # Генерируем стены в лабиринте
    for x in range(shape[0]):
        for y in range(shape[1]):
            if np.random.rand() < wall_density:
                maze[x, y, :] = 0.0

    return maze

def generate_floor_surface(shape, floor_z):
    # Создаем 3D массив для пола
    floor = np.zeros(shape, dtype=float)

    # Генерируем пол на заданной высоте
    for x in range(shape[0]):
        for y in range(shape[1]):
            floor[x, y, floor_z] = 1.0

    return floor

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
wall_density = 0.2  # Плотность стен
floor_z = 0  # Высота пола

# Генерация лабиринта
maze = generate_maze(shape, wall_density)

# Генерация пола под лабиринтом
floor = generate_floor_surface(shape, floor_z)

# Объединение лабиринта и пола логическим оператором "или"
maze = np.logical_or(maze, floor).astype(float)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "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 numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import measure
import os

def generate_lines_field(shape, num_lines, line_length):
    array = np.zeros(shape, dtype=float)
    # Генерируем ломанную линию внутри куба
    for _ in range(num_lines):
        x, y, z = np.random.randint(0, shape[0]), np.random.randint(0, shape[1]), np.random.randint(0, shape[2])
        for _ in range(line_length):  # количество сегментов ломанной линии
            dx = np.random.randint(-5, 6)
            dy = np.random.randint(-5, 6)
            dz = np.random.randint(-5, 6)
            length = int(np.sqrt(dx**2 + dy**2 + dz**2))
            for i in range(length):
                new_x = x + i * dx // length
                new_y = y + i * dy // length
                new_z = z + i * dz // length
                if 0 <= new_x < shape[0] and 0 <= new_y < shape[1] and 0 <= new_z < shape[2]:
                    array[new_x, new_y, new_z] = 1.0
                    # Делаем линии более жирными
                    if new_x > 0:
                        array[new_x-1, new_y, new_z] = 1.0
                    if new_x < shape[0] - 1:
                        array[new_x+1, new_y, new_z] = 1.0
                    if new_y > 0:
                        array[new_x, new_y-1, new_z] = 1.0
                    if new_y < shape[1] - 1:
                        array[new_x, new_y+1, new_z] = 1.0
                    if new_z > 0:
                        array[new_x, new_y, new_z-1] = 1.0
                    if new_z < shape[2] - 1:
                        array[new_x, new_y, new_z+1] = 1.0
            x, y, z = new_x, new_y, new_z
    return array

def generate_cube_field(shape, thickness):
    array = np.zeros(shape, dtype=float)
    # Добавляем куб с толщиной стенок
    for x in range(shape[0]):
        for y in range(shape[1]):
            for z in range(shape[2]):
                if x >= thickness and x < shape[0] - thickness and y >= thickness and y < shape[1] - thickness and z >= thickness and z < shape[2] - thickness:
                    array[x, y, z] = 0.0
                else:
                    array[x, y, z] = 1.0
    return array

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
num_lines = 9
line_length = 100
cube_thickness = 5

# Генерация 3D-поля с линиями
lines_field = generate_lines_field(shape, num_lines, line_length)

# Генерация 3D-поля с кубом
cube_field = generate_cube_field(shape, cube_thickness)

# Объединение полей логическим оператором "или"
field = np.logical_or(lines_field, cube_field).astype(float)

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

# Сохранение изосурфейса в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "lines.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 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 = 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])
            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

def wrap_mesh_in_convex_hull(mesh):
    hull = trimesh.convex.convex_hull(mesh.vertices)
    return hull

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

# Обернуть структуру в меш с вершинами и гранями
wrapped_mesh = wrap_mesh_in_convex_hull(cube_field)

# Удалить исходную структуру
del cube_field

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

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(wrapped_mesh.vertices[:, 0], wrapped_mesh.vertices[:, 1], wrapped_mesh.vertices[:, 2], color='r', alpha=0.5)
for face in wrapped_mesh.faces:
    v1, v2, v3 = wrapped_mesh.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
import os

# Генерация поверхности
def generate_surface(xmin, xmax, ymin, ymax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    x, y = np.meshgrid(x, y)
    z = np.zeros((ny, nx))  # создаем плоскую поверхность
    return x, y, z

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

x, y, z = generate_surface(-10, 10, -10, 10, 100, 100)

# Вытягиваем плоскость в куб
height = 5
z_cube = np.zeros((z.shape[0], z.shape[1], height))

for i in range(z.shape[0]):
    for j in range(z.shape[1]):
        for k in range(height):
            z_cube[i, j, k] = k

# Визуализируем куб
for i in range(z.shape[0]):
    for j in range(z.shape[1]):
        ax.plot([x[i, j], x[i, j]], [y[i, j], y[i, j]], [z_cube[i, j, 0], z_cube[i, j, -1]], color='b')

for i in range(z.shape[0]):
    for k in range(height):
        ax.plot([x[i, 0], x[i, -1]], [y[i, 0], y[i, -1]], [z_cube[i, 0, k], z_cube[i, -1, k]], color='b')

for j in range(z.shape[1]):
    for k in range(height):
        ax.plot([x[0, j], x[-1, j]], [y[0, j], y[-1, j]], [z_cube[0, j, k], z_cube[-1, j, k]], color='b')

ax.set_xlim(-10, 10)
ax.set_ylim(-10, 10)
ax.set_zlim(-1, height)

# Сохраняем в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "cube.obj")
with open(filename, "w") as f:
    for i in range(z.shape[0]):
        for j in range(z.shape[1]):
            for k in range(height):
                f.write(f"v {x[i, j]} {y[i, j]} {z_cube[i, j, k]}\n")
    for i in range(z.shape[0] - 1):
        for j in range(z.shape[1] - 1):
            for k in range(height - 1):
                f.write(f"f {(i * z.shape[1] * height) + (j * height) + k + 1} {(i * z.shape[1] * height) + ((j + 1) * height) + k + 1} {(i * z.shape[1] * height) + ((j + 1) * height) + (k + 1) + 1}\n")
                f.write(f"f {(i * z.shape[1] * height) + (j * height) + k + 1} {(i * z.shape[1] * height) + ((j + 1) * height) + (k + 1) + 1} {(i * z.shape[1] * height) + (j * height) + (k + 1) + 1}\n")
                f.write(f"f {(i * z.shape[1] * height) + (j * height) + k + 1} {((i + 1) * z.shape[1] * height) + (j * height) + k + 1} {((i + 1) * z.shape[1] * height) + (j * height) + (k + 1) + 1}\n")
                f.write(f"f {(i * z.shape[1] * height) + (j * height) + k + 1} {((i + 1) * z.shape[1] * height) + (j * height) + (k + 1) + 1} {(i * z.shape[1] * height) + (j * height) + (k + 1) + 1}\n")
                f.write(f"f {((i + 1) * z.shape[1] * height) + (j * height) + k + 1} {((i + 1) * z.shape[1] * height) + ((j + 1) * height) + k + 1} {((i + 1) * z.shape[1] * height) + ((j + 1) * height) + (k + 1) + 1}\n")
                f.write(f"f {((i + 1) * z.shape[1] * height) + (j * height) + k + 1} {((i + 1) * z.shape[1] * height) + ((j + 1) * height) + (k + 1) + 1} {((i + 1) * z.shape[1] * height) + (j * height) + (k + 1) + 1}\n")

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])  # Генерируем кубы на фиксированной высоте
        generate_cube(array, (x, y, shape[2] // 2), np.random.randint(4, 8))

    # Генерация коридоров между кубами
    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))
        for j in range(length):
            if abs(dx) > abs(dy):
                new_x = int(points[i][0] + j * dx // length)
                new_y = points[i][1]
            else:
                new_x = points[i][0]
                new_y = int(points[i][1] + j * dy // length)
            new_z = int(points[i][2])  # Коридоры генерируются на фиксированной высоте
            if 0 <= new_x < shape[0] and 0 <= new_y < shape[1] and 0 <= new_z < shape[2]:
                array[new_x, new_y, new_z] = 1.0
                # Делаем коридоры более жирными
                for k in range(-2, 3):
                    for l in range(-2, 3):
                        for m in range(-2, 3):
                            x1, y1, z1 = new_x + k, new_y + l, new_z + m
                            if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                                array[x1, y1, z1] = 1.0

    return array

# Функция для генерации куба в заданной точке
def generate_cube(array, point, size):
    x, y, z = int(point[0]), int(point[1]), int(point[2])
    for i in range(-size, size+1):
        for j in range(-size, size+1):
            for k in range(-size, size+1):
                new_x, new_y, new_z = x + i, y + j, z + k
                if 0 <= new_x < array.shape[0] and 0 <= new_y < array.shape[1] and 0 <= new_z < array.shape[2]:
                    array[new_x, new_y, new_z] = 1.0

# Параметры
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
from scipy.spatial import Delaunay
import os

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

    # Генерация кубов на каждом уровне
    points = []
    for level in range(3):
        for _ in range(10):
            x = np.random.randint(10, shape[0] - 10)
            y = np.random.randint(10, shape[1] - 10)
            z = level * (shape[2] // 3) + np.random.randint(10, shape[2] // 3 - 10)
            points.append([x, y, z])
            generate_cube(array, (x, y, z), np.random.randint(4, 8))

    # Генерация линий между кубами на разных уровнях
    for i in range(len(points) - 1):
        dx = points[i+1][0] - points[i][0]
        dy = points[i+1][1] - points[i][1]
        dz = points[i+1][2] - points[i][2]
        length = max(abs(dx), abs(dy), abs(dz))
        for j in range(length+1):
            new_x = int(points[i][0] + j * np.sign(dx))
            new_y = int(points[i][1] + j * np.sign(dy))
            new_z = int(points[i][2] + j * np.sign(dz))
            if 0 <= new_x < shape[0] and 0 <= new_y < shape[1] and 0 <= new_z < shape[2]:
                array[new_x, new_y, new_z] = 1.0
                # Делаем линии более жирными
                for k in range(-2, 3):
                    for l in range(-2, 3):
                        for m in range(-2, 3):
                            x1, y1, z1 = new_x + k, new_y + l, new_z + m
                            if 0 <= x1 < shape[0] and 0 <= y1 < shape[1] and 0 <= z1 < shape[2]:
                                array[x1, y1, z1] = 1.0

    return array

# Функция для генерации куба в заданной точке
def generate_cube(array, point, size):
    x, y, z = int(point[0]), int(point[1]), int(point[2])
    for i in range(-size, size+1):
        for j in range(-size, size+1):
            for k in range(-size, size+1):
                new_x, new_y, new_z = x + i, y + j, z + k
                if 0 <= new_x < array.shape[0] and 0 <= new_y < array.shape[1] and 0 <= new_z < array.shape[2]:
                    array[new_x, new_y, new_z] = 1.0

# Параметры
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], faces, 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
from scipy.spatial import Delaunay
import os

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

    # Генерация кубов на каждом уровне
    points = []
    for level in range(3):
        level_points = []
        for _ in range(10):
            x = np.random.randint(10, shape[0] - 10)
            y = np.random.randint(10, shape[1] - 10)
            level_points.append([x, y, level * (shape[2] // 3) + shape[2] // 6])
            generate_cube(array, (x, y, level * (shape[2] // 3) + shape[2] // 6), np.random.randint(4, 8))
        points.append(level_points)

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

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

    return array

# Функция для генерации куба в заданной точке
def generate_cube(array, point, size):
    x, y, z = int(point[0]), int(point[1]), int(point[2])
    for i in range(-size, size+1):
        for j in range(-size, size+1):
            for k in range(-size, size+1):
                new_x, new_y, new_z = x + i, y + j, z + k
                if 0 <= new_x < array.shape[0] and 0 <= new_y < array.shape[1] and 0 <= new_z < array.shape[2]:
                    array[new_x, new_y, new_z] = 1.0

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

# Генерация 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], faces, verts[:, 2], color='r', alpha=0.5)
plt.show()