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

[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 = 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 = 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], 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):
        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):
        for j in range(i + 1, len(points)):
            if points[i][2]!= points[j][2]:
                dx = points[i][0] - points[j][0]
                dy = points[i][1] - points[j][1]
                dz = points[i][2] - points[j][2]
                length = max(abs(dx), abs(dy), abs(dz))
                for k in range(int(length)):
                    if abs(dx) > abs(dy):
                        new_x = int(points[i][0] + k * dx // length)
                        new_y = points[i][1]
                    else:
                        new_x = points[i][0]
                        new_y = int(points[i][1] + k * dy // length)
                    new_z = points[i][2] + k * 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
                        for l in range(-2, 3):
                            for m in range(-2, 3):
                                x1, y1, z1 = new_x + l, new_y + m, 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

# Функция для генерации куба в заданной точке
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], triangles=faces, cmap='viridis', 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 = 0  
        length_x = abs(dx)
        length_y = abs(dy)
        for j in range(max(length_x, length_y)):
            if j < length_x:
                new_x = int(points[i][0] + j * dx // length_x)
            else:
                new_x = points[i+1][0]
            if j < length_y:
                new_y = int(points[i][1] + j * dy // length_y)
            else:
                new_y = points[i+1][1]
            new_z = 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):
        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_z = abs(dz)
        for j in range(length_z):
            new_x = points[i][0]
            new_y = points[i][1]
            new_z = int(points[i][2] + j * dz // length_z)
            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):
        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 = 0  
        length_x = abs(dx)
        length_y = abs(dy)
        for j in range(max(length_x, length_y)):
            if j < length_x:
                new_x = int(points[i][0] + j * dx // length_x)
            else:
                new_x = points[i+1][0]
            if j < length_y:
                new_y = int(points[i][1] + j * dy // length_y)
            else:
                new_y = points[i+1][1]
            new_z = 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):
        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_z = abs(dz)
        for _ in range(10):
            new_x = points[i][0] + np.random.randint(-10, 10)
            new_y = points[i][1] + np.random.randint(-10, 10)
            for j in range(length_z):
                new_z = int(points[i][2] + j * dz // length_z)
                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]

А это идеально подойдет для создания 404 уровня бэкрумса!

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

# Создание дырок
def create_holes(x, y, z, max_radius, max_depth):
    holes = []
    for i in range(10):  # генерируем 10 дырок
        x_hole = random.uniform(x.min(), x.max())
        y_hole = random.uniform(y.min(), y.max())
        radius = random.uniform(0.1, max_radius)
        depth = random.uniform(0, max_depth)

        # Создаем дырку с правильным радиусом и глубиной
        x_hole_grid = np.linspace(x_hole - radius, x_hole + radius, 100)
        y_hole_grid = np.linspace(y_hole - radius, y_hole + radius, 100)
        x_hole_grid, y_hole_grid = np.meshgrid(x_hole_grid, y_hole_grid)
        z_hole_grid = np.zeros((100, 100))
        x_hole_grid, y_hole_grid, z_hole_grid = ndimage.gaussian_filter(x_hole_grid, sigma=1), ndimage.gaussian_filter(y_hole_grid, sigma=1), ndimage.gaussian_filter(z_hole_grid, sigma=1)
        x_hole_grid, y_hole_grid, z_hole_grid = ndimage.gaussian_filter(x_hole_grid, sigma=1), ndimage.gaussian_filter(y_hole_grid, sigma=1), ndimage.gaussian_filter(z_hole_grid, sigma=1)

        # Смещаем дырку на поверхность
        x_min = x_hole_grid.min()
        x_max = x_hole_grid.max()
        y_min = y_hole_grid.min()
        y_max = y_hole_grid.max()
        for i in range(int(x.shape[0])):
            for j in range(int(x.shape[1])):
                if x[i, j] >= x_min and x[i, j] <= x_max and y[i, j] >= y_min and y[i, j] <= y_max:
                    z[i, j] = -depth

        holes.append((x_hole, y_hole, radius, depth))

    return x, y, z, holes

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

x, y, z = generate_surface(-10, 10, -10, 10, 100, 100)
x, y, z, holes = create_holes(x, y, z, 5, 5)

ax.plot_surface(x, y, z, cmap='viridis', alpha=0.5)
for hole in holes:
    x_hole, y_hole, radius, depth = hole
    x_min = x_hole - radius
    x_max = x_hole + radius
    y_min = y_hole - radius
    y_max = y_hole + radius
    ax.bar3d(x_min, y_min, -depth, x_max-x_min, y_max-y_min, 0, color='r', alpha=0.5)

# Create a copy of the surface
x_copy, y_copy, z_copy = x, y, z.copy()

# Shift the copy of the surface
z_copy += 1  # You can adjust this value to change the distance between the two surfaces

# Plot the copy of the surface
ax.plot_surface(x_copy, y_copy, z_copy, cmap='viridis', alpha=0.5)

# Connect the points of the two surfaces to create a parallelepiped
x_concat = np.concatenate((x.ravel(), x_copy.ravel()))
y_concat = np.concatenate((y.ravel(), y_copy.ravel()))
z_concat = np.concatenate((z.ravel(), z_copy.ravel()))

# Plot the edges of the parallelepiped
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[0, -1]], 'k')  # bottom
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[-1, 0]], 'k')  # front
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[0, -1]], 'k')  # back
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[0, -1]], 'k')  # top
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[0, -1]], 'k')  # left
ax.plot3D(x_concat[[0, -1]], y_concat[[0, -1]], z_concat[[0, -1]], 'k')  # right

# Save the OBJ file to the desktop
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = "parallelepiped.obj"
with open(os.path.join(desktop_path, filename), "w") as f:
    for i in range(len(x_concat)):
        f.write('v {} {} {}\n'.format(x_concat[i], y_concat[i], z_concat[i]))
    for i in range(len(x_concat) - 1):
        f.write('f {} {} {}\n'.format(i + 1, i + 2, i + 3))
    f.write('f {} {} {}\n'.format(len(x_concat) - 1, len(x_concat), len(x_concat) + 1))
    f.write('f {} {} {}\n'.format(len(x_concat) - 1, len(x_concat) + 1, len(x_concat) + 2))
    f.write('f {} {} {}\n'.format(len(x_concat) - 1, len(x_concat) + 2, len(x_concat) + 3))

# Show the plot
plt.show()

[MakarovDs]

Ещё одна странная структура в копилку мира глитча!

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

# Генерация поверхности
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

# Создание дырок
def create_holes(x, y, z, max_radius, max_depth):
    holes = []
    for i in range(10):  # генерируем 10 дырок
        x_hole = random.uniform(x.min(), x.max())
        y_hole = random.uniform(y.min(), y.max())
        radius = random.uniform(0.1, max_radius)
        depth = random.uniform(0, max_depth)

        # Создаем дырку с правильным радиусом и глубиной
        x_hole_grid = np.linspace(x_hole - radius, x_hole + radius, 100)
        y_hole_grid = np.linspace(y_hole - radius, y_hole + radius, 100)
        x_hole_grid, y_hole_grid = np.meshgrid(x_hole_grid, y_hole_grid)
        z_hole_grid = np.zeros((100, 100))
        x_hole_grid, y_hole_grid, z_hole_grid = ndimage.gaussian_filter(x_hole_grid, sigma=1), ndimage.gaussian_filter(y_hole_grid, sigma=1), ndimage.gaussian_filter(z_hole_grid, sigma=1)
        x_hole_grid, y_hole_grid, z_hole_grid = ndimage.gaussian_filter(x_hole_grid, sigma=1), ndimage.gaussian_filter(y_hole_grid, sigma=1), ndimage.gaussian_filter(z_hole_grid, sigma=1)
        x_hole_grid, y_hole_grid, z_hole_grid = ndimage.gaussian_filter(x_hole_grid, sigma=1), ndimage.gaussian_filter(y_hole_grid, sigma=1), ndimage.gaussian_filter(z_hole_grid, sigma=1)

        # Смещаем дырку на поверхность
        x_min = x_hole_grid.min()
        x_max = x_hole_grid.max()
        y_min = y_hole_grid.min()
        y_max = y_hole_grid.max()
        for i in range(int(x.shape[0])):
            for j in range(int(x.shape[1])):
                if x[i, j] >= x_min and x[i, j] <= x_max and y[i, j] >= y_min and y[i, j] <= y_max:
                    z[i, j] = -depth

        holes.append((x_hole, y_hole, radius, depth))

    return x, y, z, holes

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

x, y, z = generate_surface(-10, 10, -10, 10, 100, 100)
x, y, z, holes = create_holes(x, y, z, 5, 5)

# Создаем копию плоскости и помещаем ее ровно под низ
z_copy = z - 5  # глубина параллелепипеда

# Соединяем все точки этих плоскостей вместе
for i in range(len(x)):
    for j in range(len(y)):
        ax.plot([x[i, j], x[i, j]], [y[i, j], y[i, j]], [z[i, j], z_copy[i, j]], color='b')

ax.plot_surface(x, y, z, cmap='viridis', alpha=0.5)
ax.plot_surface(x, y, z_copy, cmap='viridis', alpha=0.5)

for hole in holes:
    x_hole, y_hole, radius, depth = hole
    x_min = x_hole - radius
    x_max = x_hole + radius
    y_min = y_hole - radius
    y_max = y_hole + radius
    ax.bar3d(x_min, y_min, -depth, x_max-x_min, y_max-y_min, 0, color='r', alpha=0.5)

# Сохранение файла в OBJ
import os
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "surface_with_holes.obj")
with open(filename, "w") as f:
    for i in range(len(x)):
        for j in range(len(y)):
            f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
            f.write(f"v {x[i, j]} {y[i, j]} {z_copy[i, j]}\n")
    for hole in holes:
        x_hole, y_hole, radius, depth = hole
        x_min = x_hole - radius
        x_max = x_hole + radius
        y_min = y_hole - radius
        y_max = y_hole + radius
        f.write(f"v {x_min} {y_min} -{depth}\n")
        f.write(f"v {x_max} {y_min} -{depth}\n")
        f.write(f"v {x_max} {y_max} -{depth}\n")
        f.write(f"v {x_min} {y_max} -{depth}\n")
        f.write(f"f {len(x)*len(y)+1} {len(x)*len(y)+2} {len(x)*len(y)+3}\n")
        f.write(f"f {len(x)*len(y)+1} {len(x)*len(y)+3} {len(x)*len(y)+4}\n")
    for i in range(len(x) - 1):
        for j in range(len(y) - 1):
            f.write(f"f {i * len(y) + j + 1} {(i + 1) * len(y) + j + 1} {(i + 1) * len(y) + j + 2}\n")
            f.write(f"f {i * len(y) + j + 1} {(i + 1) * len(y) + j + 2} {i * len(y) + j + 2}\n")
            f.write(f"f {i * len(y) + j + len(x)*len(y) + 1} {(i + 1) * len(y) + j + len(x)*len(y) + 1} {(i + 1) * len(y) + j + len(x)*len(y) + 2}\n")
            f.write(f"f {i * len(y) + j + len(x)*len(y) + 1} {(i + 1) * len(y) + j + len(x)*len(y) + 2} {i * len(y) + j + len(x)*len(y) + 2}\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])  # Генерируем точки на фиксированной высоте

    # Генерация коридоров между точками
    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])  # Коридоры генерируются на фиксированной высоте
            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

# Параметры
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_corridors_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])

    # Генерация коридоров между точками
    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_x = abs(dx)
        length_y = abs(dy)
        length_z = abs(dz)
        max_length = max(length_x, length_y, length_z)
        for j in range(max_length):
            if j < length_x:
                new_x = int(points[i][0] + j * dx // length_x)
            else:
                new_x = points[i+1][0]
            if j < length_y:
                new_y = int(points[i][1] + j * dy // length_y)
            else:
                new_y = points[i+1][1]
            if j < length_z:
                new_z = int(points[i][2] + j * dz // length_z)
            else:
                new_z = points[i+1][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

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

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

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

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

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

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

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

# Создание изосурфейса
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, 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)

# Объединение вершин и граней в один объект
verts = np.concatenate((verts, verts + [shape[0], 0, 0], verts + [0, shape[1], 0], verts + [0, 0, shape[2]]))
faces = np.concatenate((faces, faces + [len(verts) // 3, len(verts) // 3 + 1, len(verts) // 3 + 2]))

# Сохранение изосурфейса в 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()