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

[MakarovDs]

Остроугольные коридоры бэкрумс с комнтами

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

# Функция для создания случайного коридора
def create_corridor():
    # Создание основного куба с размерами коридора
    corridor_length = 10
    corridor_width = 2
    corridor_height = 2
    cube = trimesh.creation.box(extents=(corridor_length, corridor_width, corridor_height))

    # Размеры отверстий
    hole_size_x = [-1.0, 1.0, 1.0]  # Отверстия по оси X

    # Определяем позиции для столбов по оси X (по одному слева и справа)
    hole_positions_x = [
        [corridor_length / 2 - hole_size_x[0] / 2, 0, 0],  # столб слева
        [-corridor_length / 2 + hole_size_x[0] / 2, 0, 0],   # столб справа
    ]

    # Создание и вычитание столбов по оси X
    for pos in hole_positions_x:
        hole = trimesh.creation.box(extents=(1.0, 1.0, 1.0))
        hole.apply_translation(pos)
        cube = cube.difference(hole)

    return cube

# Функция для создания комнаты
def create_room():
    room_size = 5
    room = trimesh.creation.box(extents=(room_size, room_size, room_size))
    return room

# Функция для объединения коридоров и комнат в лабиринт
def create_labyrinth(num_corridors, num_rooms):
    labyrinth = None
    for _ in range(num_corridors):
        corridor = create_corridor()
        if labyrinth is None:
            labyrinth = corridor
        else:
            corridor.apply_translation([random.uniform(-5, 5), random.uniform(-5, 5), 0])
            rotation_matrix = trimesh.transformations.rotation_matrix(np.pi/2, [0, 0, 1])
            if random.random() < 0.5:
                corridor.apply_transform(rotation_matrix)
            labyrinth = labyrinth.union(corridor)

    for _ in range(num_rooms):
        room = create_room()
        room.apply_translation([random.uniform(-10, 10), random.uniform(-10, 10), 0])
        labyrinth = labyrinth.union(room)

    return labyrinth

# Создание лабиринта коридоров и комнат
num_corridors = 10
num_rooms = 5
labyrinth = create_labyrinth(num_corridors, num_rooms)

# Сохранение лабиринта в OBJ файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")

# Сохранение лабиринта в OBJ файл
filename = os.path.join(desktop_path, "labyrinth.obj")
labyrinth.export(filename)
print(f"Model saved as {filename}")

# Визуализация лабиринта
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(labyrinth.vertices[:, 0], labyrinth.vertices[:, 1], labyrinth.vertices[:, 2], color='r', alpha=0.5)
plt.show()

[MakarovDs]

Фрактал Макарова

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

# Функция для генерации случайных самоподобий
def choose_random_shape(shapes, probabilities):
    return np.random.choice(shapes, p=probabilities)

def create_surface_from_points(points, grid_size):
    array = np.zeros(grid_size, dtype=bool)

    for point in points:
        idx = np.floor(point).astype(int)
        if np.all(idx >= 0) and np.all(idx < np.array(grid_size)):
            array[tuple(idx)] = 1

    return array

# Функция для генерации фигур с большей плотностью
def draw_shape(points, shape_type, center, size):
    if shape_type == 0:  # квадрат
        x, y, z = center
        half_size = size / 2
        for dx in np.linspace(-half_size, half_size, num=5):  # Увеличено количество точек
            for dy in np.linspace(-half_size, half_size, num=5):
                for dz in np.linspace(-half_size, half_size, num=5):
                    points.append([x + dx, y + dy, z + dz])
    elif shape_type == 1:  # шар
        phi, theta = np.mgrid[0:2 * np.pi:20j, 0:np.pi:10j]  # Увеличено количество полярных углов
        x = center[0] + size * np.outer(np.cos(phi), np.sin(theta))
        y = center[1] + size * np.outer(np.sin(phi), np.sin(theta))
        z = center[2] + size * np.outer(np.ones(np.size(phi)), np.cos(theta))
        points.extend(np.c_[x.flatten(), y.flatten(), z.flatten()])
    elif shape_type == 2:  # ромб
        x, y, z = center
        points.extend([[x, y + size / 2, z], [x, y - size / 2, z],
                       [x + size / 2, y, z], [x - size / 2, y, z]])

def draw_fractal_makarov(x, y, z, length, min_length, points, shapes, probabilities, depth):
    if length > min_length and depth < 5:  # Увеличенная глубина рекурсии
        shape_type = choose_random_shape(shapes, probabilities)
        draw_shape(points, shape_type, (x, y, z), length)

        for angle in np.linspace(-np.pi / 4, np.pi / 4, num=3):  # Увеличенное количество углов для большей плотности
            draw_fractal_makarov(x + length * np.cos(angle), 
                                  y + length * np.sin(angle), 
                                  z, length * 0.5, min_length, points, shapes, probabilities, depth + 1)

def save_fractal(verts, faces, filename):
    with open(filename, 'w') as f:
        for v in verts:
            f.write('v {:.6f} {:.6f} {:.6f}\n'.format(v[0], v[1], v[2]))
        for face in faces:
            f.write('f {} {} {}\n'.format(face[0]+1, face[1]+1, face[2]+1))

# Начальные параметры
x, y, z = 64, 64, 64  # Центрирование фрактала
length = 20  # Начальная длина
min_length = 1
shapes = [0, 1, 2]  # квадрат, шар, ромб
probabilities = [0.3, 0.4, 0.3]  # вероятности выбора

points = []
draw_fractal_makarov(x, y, z, length, min_length, points, shapes, probabilities, depth=0)

# Преобразование точек в массив
points = np.array(points)
grid_size = (128, 128, 128)
scaled_points = (points - np.min(points, axis=0)) / (np.max(points, axis=0) - np.min(points, axis=0)) * grid_size[0]
scaled_points = np.clip(scaled_points, 0, np.array(grid_size) - 1)

# Создаем 3D массив на основе масштабированных точек
array = create_surface_from_points(scaled_points, grid_size)

# Создание изосурфейса для всех линий фрактала
verts, faces, _, _ = measure.marching_cubes(array, level=0.5)

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
verts -= np.min(verts, axis=0)  # Центрируем модель
poly3d = Poly3DCollection(verts[faces], alpha=0.5, edgecolor='k')
ax.add_collection3d(poly3d)

# Настройки отображения
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.auto_scale_xyz([0, grid_size[0]], [0, grid_size[1]], [0, grid_size[2]])
plt.show()

# Сохранение фрактала в формате OBJ на Рабочий стол
desktop_path = os.path.join(os.path.expanduser('~'), 'Desktop')
output_path = os.path.join(desktop_path, 'fractal.obj')
save_fractal(verts, faces, output_path)
print(f"Модель сохранена как {output_path}")

[MakarovDs]

??? ??? ?? ? ??

import numpy as np
import os
from scipy.spatial import Delaunay

# Функция для генерации случайных самоподобий
def choose_random_shape(shapes, probabilities):
    return np.random.choice(shapes, p=probabilities)

def draw_shape(points, shape_type, center, size):
    if shape_type == 0:  # квадрат
        x, y, z = center
        half_size = size / 2
        for dx in np.linspace(-half_size, half_size, num=5):
            for dy in np.linspace(-half_size, half_size, num=5):
                for dz in np.linspace(-half_size, half_size, num=5):
                    points.append([x + dx, y + dy, z + dz])
    elif shape_type == 1:  # шар
        phi, theta = np.mgrid[0:2 * np.pi:20j, 0:np.pi:10j]
        x = center[0] + size * np.outer(np.cos(phi), np.sin(theta))
        y = center[1] + size * np.outer(np.sin(phi), np.sin(theta))
        z = center[2] + size * np.outer(np.ones(np.size(phi)), np.cos(theta))
        points.extend(np.c_[x.flatten(), y.flatten(), z.flatten()])
    elif shape_type == 2:  # ромб
        x, y, z = center
        points.extend([[x, y + size / 2, z], [x, y - size / 2, z],
                       [x + size / 2, y, z], [x - size / 2, y, z]])

def draw_super_fractal(x, y, z, length, min_length, points, shapes, probabilities, depth):
    if length > min_length and depth < 5:
        shape_type = choose_random_shape(shapes, probabilities)
        draw_shape(points, shape_type, (x, y, z), length)

        for angle in np.linspace(-np.pi / 4, np.pi / 4, num=3):
            new_length = length * np.random.uniform(0.3, 0.7)
            new_x = x + length * np.cos(angle) * np.random.uniform(0.5, 1.5)
            new_y = y + length * np.sin(angle) * np.random.uniform(0.5, 1.5)
            draw_super_fractal(new_x, new_y, z, new_length, min_length, points, shapes, probabilities, depth + 1)

def save_mesh_as_obj(points, faces, filename):
    with open(filename, 'w') as f:
        for v in points:
            f.write('v {:.6f} {:.6f} {:.6f}\n'.format(v[0], v[1], v[2]))
        for face in faces:
            f.write('f {} {} {}\n'.format(face[0] + 1, face[1] + 1, face[2] + 1))

# Начальные параметры
x, y, z = 64, 64, 64
length = 20
min_length = 1
shapes = [0, 1, 2]  # квадрат, шар, ромб
probabilities = [0.3, 0.4, 0.3]

points = []
draw_super_fractal(x, y, z, length, min_length, points, shapes, probabilities, depth=0)

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

# Выполнение триангуляции
tri = Delaunay(points[:, :2])  # Используем только X и Y для 2D триангуляции
faces = tri.simplices  # Получение индексов вершин для треугольников

# Сохранение меша в формате OBJ на Рабочий стол
desktop_path = os.path.join(os.path.expanduser('~'), 'Desktop')
output_path = os.path.join(desktop_path, 'super_fractal_mesh.obj')
save_mesh_as_obj(points, faces, output_path)
print(f"Модель сохранена как {output_path}")

[MakarovDs]

Процедурный генератор абстрактных скульптур 1

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
import os

# Функция для генерации случайных самоподобий
def choose_random_shape(shapes, probabilities):
    return np.random.choice(shapes, p=probabilities)

def draw_shape(shape_type, center, size):
    vertices = []
    faces = []
    if shape_type == 0:  # Куб
        x, y, z = center
        half_size = size / 2
        # Вершины куба
        vertices = [
            [x - half_size, y - half_size, z - half_size],
            [x + half_size, y - half_size, z - half_size],
            [x + half_size, y + half_size, z - half_size],
            [x - half_size, y + half_size, z - half_size],
            [x - half_size, y - half_size, z + half_size],
            [x + half_size, y - half_size, z + half_size],
            [x + half_size, y + half_size, z + half_size],
            [x - half_size, y + half_size, z + half_size]
        ]
        # Грани куба (по 2 треугольника на каждую грань)
        faces = [
            [0, 1, 2], [0, 2, 3],  # Нижняя грань
            [4, 5, 6], [4, 6, 7],  # Верхняя грань
            [0, 1, 5], [0, 5, 4],  # Передняя грань
            [1, 2, 6], [1, 6, 5],  # Правая грань
            [2, 3, 7], [2, 7, 6],  # Задняя грань
            [3, 0, 4], [3, 4, 7]   # Левая грань
        ]
    elif shape_type == 1:  # Шар
        phi, theta = np.mgrid[0:2 * np.pi:20j, 0:np.pi:10j]
        x = center[0] + size * np.outer(np.cos(phi), np.sin(theta))
        y = center[1] + size * np.outer(np.sin(phi), np.sin(theta))
        z = center[2] + size * np.outer(np.ones(np.size(phi)), np.cos(theta))
        vertices = np.c_[x.flatten(), y.flatten(), z.flatten()]
        faces = []  # Треугольники не определяются для шара простым способом
        for i in range(len(theta) - 1):
            for j in range(len(phi) - 1):
                a = i * len(phi) + j
                b = a + len(phi)
                c = a + 1
                d = b + 1
                faces.append([a, c, b])
                faces.append([c, d, b])

    elif shape_type == 2:  # Ромб
        x, y, z = center
        vertices = [
            [x, y + size / 2, z], 
            [x, y - size / 2, z],
            [x + size / 2, y, z], 
            [x - size / 2, y, z]
        ]
        faces = [[0, 1, 2], [1, 3, 2]]  # Два треугольника образуют ромб

    return np.array(vertices), faces

def draw_super_fractal(x, y, z, length, min_length, points, meshes, shapes, probabilities, depth):
    if length > min_length and depth < 5:
        shape_type = choose_random_shape(shapes, probabilities)
        vertices, faces = draw_shape(shape_type, (x, y, z), length)

        # Обновление индексов вершин
        index_offset = len(points)
        points.extend(vertices)  # Объединяем все вершины
        for face in faces:
            meshes.append([idx + index_offset for idx in face])  # Сдвигаем индексы

        # Случайные углы и длины для создания сложности
        for angle in np.linspace(-np.pi / 4, np.pi / 4, num=3):
            new_length = length * np.random.uniform(0.4, 0.8)  # Случайное изменение длины
            draw_super_fractal(
                x + new_length * np.cos(angle),
                y + new_length * np.sin(angle),
                z,
                new_length,
                min_length,
                points,
                meshes,
                shapes,
                probabilities,
                depth + 1
            )

# Функция для сохранения фрактала
def save_fractal(points, meshes, filename):
    # Сохраняем в формате .obj
    with open(filename, 'w') as f:
        for v in points:
            f.write('v {:.6f} {:.6f} {:.6f}\n'.format(v[0], v[1], v[2]))
        for face in meshes:
            f.write('f {} {} {}\n'.format(face[0] + 1, face[1] + 1, face[2] + 1))  # .obj начинается с 1

    print(f"Модель сохранена как {filename}")

# Начальные параметры
x, y, z = 64, 64, 64  # Центрирование фрактала
length = 20  # Начальная длина
min_length = 1
shapes = [0, 1, 2]  # Куб, шар, ромб
probabilities = [0.3, 0.4, 0.3]  # вероятности выбора

points = []
meshes = []
draw_super_fractal(x, y, z, length, min_length, points, meshes, shapes, probabilities, depth=0)

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

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

# Создание меша
poly3d = Poly3DCollection(points[meshes], alpha=0.5, edgecolor='k')
ax.add_collection3d(poly3d)

# Настройки отображения
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.auto_scale_xyz([0, 128], [0, 128], [0, 128])
plt.show()

# Сохранение фрактала в формате OBJ на Рабочий стол
desktop_path = os.path.join(os.path.expanduser('~'), 'Desktop')
output_path = os.path.join(desktop_path, 'fractal.obj')
save_fractal(points, meshes, output_path)

[MakarovDs]

Коридор с комнатой миниатюра

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

def create_hole(position, size):
    """Создает куб в форме отверстия."""
    hole = trimesh.creation.box(extents=size)
    hole.apply_translation(position)
    return hole

def generate_cube_with_corridor_and_room():
    # Создание куба
    cube = trimesh.creation.box(extents=(12, 4, 12))

    # Размеры коридора
    corridor_size = (1.0, 1.0, 1.0)  # Размеры коридора по осям (X, Y, Z)

    # Определяем позицию коридора
    corridor_position = [1, 2, -8]  # Коридор идет вверх

    # Создание коридора и вычитание из куба
    corridor = create_hole(corridor_position, corridor_size)
    cube = cube.difference(corridor)

    # Генерация комнаты, которая будет соединяться с коридором
    room = trimesh.creation.box(extents=(30, 2, 1.5))  # Размеры комнаты
    room_position = [10.0, -1.0, 0.0]  # Позиция комнаты (размещаем над кубом)
    room.apply_translation(room_position)

    # Объединение куба и комнаты
    combined_mesh = cube.union(room)

    return combined_mesh

# Генерация куба с коридором и комнатой
mesh = generate_cube_with_corridor_and_room()

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

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

[MakarovDs]

import numpy as np
import trimesh
import matplotlib.pyplot as plt
import os
import random
from scipy.spatial.transform import Rotation as R

def create_hole(position, size):
    """Создает куб в форме отверстия."""
    hole = trimesh.creation.box(extents=size)
    hole.vertices += position
    return hole

def generate_cube_with_corridor_and_room():
    # Создание куба
    cube = trimesh.creation.box(extents=(12, 4, 12))

    # Размеры коридора
    corridor_size = (1.0, 1.0, 1.0)  # Размеры коридора по осям (X, Y, Z)

    # Определяем позицию коридора
    corridor_position = [1, 2, -8]  # Коридор идет вверх

    # Создание коридора и вычитание из куба
    corridor = create_hole(corridor_position, corridor_size)
    cube = cube.difference(corridor)

    # Генерация комнаты, которая будет соединяться с коридором
    room = trimesh.creation.box(extents=(30, 2, 1.5))  # Размеры комнаты
    room_position = [10.0, -1.0, 0.0]  # Позиция комнаты (размещаем над кубом)
    room.vertices += room_position

    # Объединение куба и комнаты
    combined_mesh = cube.union(room)

    return combined_mesh

def generate_multiple_copies(mesh, num_copies):
    multiple_meshes = []
    for _ in range(num_copies):
        copy_mesh = mesh.copy()
        # Вращаем меш на случайный угол вокруг оси Y
        angle = random.uniform(0, 2 * np.pi)
        rotation = R.from_euler('y', angle, degrees=False)
        transform = rotation.as_matrix()
        # Добавляем строку и столбец к матрице преобразования
        transform = np.vstack((transform, [0, 0, 0]))
        transform = np.hstack((transform, [[0], [0], [0], [1]]))
        copy_mesh = copy_mesh.apply_transform(transform)
        # Перемещаем меш на случайную позицию
        copy_mesh.vertices += [random.uniform(-20, 30), 1, random.uniform(-20, 30)]
        multiple_meshes.append(copy_mesh)
    return multiple_meshes

def main():
    # Генерация куба с коридором и комнатой
    mesh = generate_cube_with_corridor_and_room()

    # Генерация множества копий
    multiple_meshes = generate_multiple_copies(mesh, 10)

    # Объединение копий в одну структуру
    combined_mesh = multiple_meshes[0]
    for i in range(1, len(multiple_meshes)):
        combined_mesh = combined_mesh.union(multiple_meshes[i])

    # Сохранение в OBJ файл
    desktop_path = os.path.expanduser("~")
    filename = os.path.join(desktop_path, "Desktop", "multiple_copies.obj")
    combined_mesh.export(filename)
    print(f"Файл сохранен как {filename}")

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

if __name__ == "__main__":
    main()

[MakarovDs]

Точнейшая версия бэкрумс но структуры повернуты случайно на все 360 градусов

import numpy as np
import trimesh
import matplotlib.pyplot as plt
import os
import random
from scipy.spatial.transform import Rotation as R

def create_hole(position, size):
    """Создает куб в форме отверстия."""
    hole = trimesh.creation.box(extents=size)
    hole.vertices += position
    return hole

def generate_cube_with_corridor_and_room():
    # Создание куба
    cube = trimesh.creation.box(extents=(12, 4, 12))

    # Размеры коридора
    corridor_size = (1.0, 1.0, 1.0)

    # Определяем позицию коридора
    corridor_position = [1, 2, -8]

    # Создание коридора и вычитание из куба
    corridor = create_hole(corridor_position, corridor_size)
    cube = cube.difference(corridor)

    # Генерация комнаты
    room = trimesh.creation.box(extents=(30, 2, 1.5))
    room_position = [10.0, -1.0, 0.0]
    room.vertices += room_position

    # Объединение куба и комнаты
    combined_mesh = cube.union(room)

    return combined_mesh

def generate_multiple_copies(mesh, num_copies):
    multiple_meshes = []
    for _ in range(num_copies):
        copy_mesh = mesh.copy()
        # Задаем случайное направление поворота по осям
        direction = random.choice(['x', 'y', 'z'])
        angle = random.uniform(0, 2 * np.pi)

        # Поворот вокруг заданной оси
        if direction == 'x':
            rotation = R.from_euler('x', angle)
        elif direction == 'y':
            rotation = R.from_euler('y', angle)
        else:  # direction == 'z'
            rotation = R.from_euler('z', angle)

        transform = rotation.as_matrix()
        transform = np.vstack((transform, [0, 0, 0]))
        transform = np.hstack((transform, [[0], [0], [0], [1]]))
        copy_mesh = copy_mesh.apply_transform(transform)

        # Перемещение меша на случайную позицию
        copy_mesh.vertices += [random.uniform(-20, 30), 1, random.uniform(-20, 30)]
        multiple_meshes.append(copy_mesh)
    return multiple_meshes

def main():
    # Генерация куба с коридором и комнатой
    mesh = generate_cube_with_corridor_and_room()

    # Генерация множества копий
    multiple_meshes = generate_multiple_copies(mesh, 10)

    # Объединение копий в одну структуру
    combined_mesh = multiple_meshes[0]
    for i in range(1, len(multiple_meshes)):
        combined_mesh = combined_mesh.union(multiple_meshes[i])

    # Сохранение в OBJ файл
    desktop_path = os.path.expanduser("~")
    filename = os.path.join(desktop_path, "Desktop", "multiple_copies.obj")
    combined_mesh.export(filename)
    print(f"Файл сохранен как {filename}")

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

if __name__ == "__main__":
    main()

[MakarovDs]

Точнейшая версия бэкрумс но это просто остроугольные коридоры полые

import numpy as np
import trimesh
import matplotlib.pyplot as plt
import os
import random
from scipy.spatial.transform import Rotation as R

def create_hole(position, size):
    """Создает куб в форме отверстия."""
    hole = trimesh.creation.box(extents=size)
    hole.vertices += position
    return hole

def generate_cube_with_corridor_and_room():
    # Создание куба
    cube = trimesh.creation.box(extents=(1, 1, 1))

    # Размеры коридора
    corridor_size = (1.0, 1.0, 1.0)  # Размеры коридора по осям (X, Y, Z)

    # Определяем позицию коридора
    corridor_position = [1, 2, -8]  # Коридор идет вверх

    # Создание коридора и вычитание из куба
    corridor = create_hole(corridor_position, corridor_size)
    cube = cube.difference(corridor)

    # Генерация комнаты, которая будет соединяться с коридором
    room = trimesh.creation.box(extents=(30, 2, 2))  # Размеры комнаты
    room_position = [10.0, 0.0, 0.0]  # Позиция комнаты (размещаем над кубом)
    room.vertices += room_position

    # Объединение куба и комнаты
    combined_mesh = cube.union(room)

    return combined_mesh

def generate_multiple_copies(mesh, num_copies):
    multiple_meshes = []
    for _ in range(num_copies):
        copy_mesh = mesh.copy()
        # Вращаем меш на случайный угол вокруг оси Y
        angle = random.uniform(0, 2 * np.pi)
        rotation = R.from_euler('y', angle, degrees=False)
        transform = rotation.as_matrix()
        # Добавляем строку и столбец к матрице преобразования
        transform = np.vstack((transform, [0, 0, 0]))
        transform = np.hstack((transform, [[0], [0], [0], [1]]))
        copy_mesh = copy_mesh.apply_transform(transform)
        # Перемещаем меш на случайную позицию
        copy_mesh.vertices += [random.uniform(-20, 30), 1, random.uniform(-20, 30)]
        multiple_meshes.append(copy_mesh)
    return multiple_meshes

def main():
    # Генерация куба с коридором и комнатой
    mesh = generate_cube_with_corridor_and_room()

    # Генерация множества копий
    multiple_meshes = generate_multiple_copies(mesh, 10)

    # Объединение копий в одну структуру
    combined_mesh = multiple_meshes[0]
    for i in range(1, len(multiple_meshes)):
        combined_mesh = combined_mesh.union(multiple_meshes[i])

    # Сохранение в OBJ файл
    desktop_path = os.path.expanduser("~")
    filename = os.path.join(desktop_path, "Desktop", "multiple_copies.obj")
    combined_mesh.export(filename)
    print(f"Файл сохранен как {filename}")

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

if __name__ == "__main__":
    main()