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

[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()

[MakarovDs]

Процедурный генератор случайных объектов.

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

def create_obj_file(vertex, edges, filename):
    """
    Создает OBJ-файл из заданных вершин и граней.

    :param vertex: Массив вершин в формате [(x, y, z),...]
    :param edges: Массив граней в формате [(v1, v2, v3),...], где v1, v2, v3 - индексы вершин
    :param filename: Имя файла OBJ
    """
    with open(filename, 'w') as f:
        # Записать вершины
        for i, v in enumerate(vertex):
            f.write(f"v {v[0]} {v[1]} {v[2]}\n")

        # Записать грани
        for edge in edges:
            f.write(f"f {edge[0] + 1} {edge[1] + 1} {edge[2] + 1}\n")

def generate_random_vertex(num_vertex, min_val, max_val):
    """
    Генерирует случайные вершины.

    :param num_vertex: Количество вершин
    :param min_val: Минимальное значение координаты
    :param max_val: Максимальное значение координаты
    :return: Список вершин в формате [(x, y, z),...]
    """
    return [(random.uniform(min_val, max_val), random.uniform(min_val, max_val), random.uniform(min_val, max_val)) for _ in range(num_vertex)]

def generate_random_edges(num_vertex, num_edges):
    """
    Генерирует случайные грани.

    :param num_vertex: Количество вершин
    :param num_edges: Количество граней
    :return: Список граней в формате [(v1, v2, v3),...]
    """
    edges = []
    for _ in range(num_edges):
        v1, v2, v3 = random.sample(range(num_vertex), 3)
        edges.append((v1, v2, v3))
    return edges

# Генерация случайных вершин и граней
num_vertex = random.randint(5, 20)
num_edges = random.randint(5, 20)
vertex = generate_random_vertex(num_vertex, -10, 10)
edges = generate_random_edges(num_vertex, num_edges)

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

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

def animate(frame):
    ax.clear()
    num_vertex = random.randint(5, 20)
    num_edges = random.randint(5, 20)
    vertex = generate_random_vertex(num_vertex, -10, 10)
    edges = generate_random_edges(num_vertex, num_edges)
    ax.scatter(*zip(*vertex), color='r', alpha=0.5)
    for edge in edges:
        ax.plot3D(*zip(vertex[edge[0]], vertex[edge[1]], vertex[edge[2]]), c='b')
ani = animation.FuncAnimation(fig, animate, frames=range(100), interval=100, repeat=True)
plt.show()

Вероятность того, что сгенерируется структура, напоминающая пистолет, является сложной проблемой, поскольку она зависит от многих факторов, таких как количество вершин, количество граней, диапазон координат и т. д.

Однако, мы можем попытаться оценить эту вероятность с помощью некоторых приближенных методов.

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

Пистолет является сравнительно сложной структурой, состоящей из многих элементов, таких как ствол, рукоятка, курок и т. д. Следовательно, вероятность того, что сгенерируется структура, напоминающая пистолет, будет низкой, если количество вершин и граней будет небольшим.

Давайте рассмотрим следующую оценку:

1)Вероятность того, что сгенерируется структура, состоящая из 10 вершин и 10 граней, является примерно 10^(-10), поскольку каждая вершина и каждая грань имеют 10 возможных вариантов расположения.

2)Вероятность того, что сгенерируется структура, состоящая из 100 вершин и 100 граней, является примерно 10^(-100), поскольку каждая вершина и каждая грань имеют 100 возможных вариантов расположения.

Как видим, вероятность того, что сгенерируется структура, напоминающая пистолет, быстро уменьшается с увеличением количества вершин и граней.

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

В общем, вероятность того, что сгенерируется структура, напоминающая пистолет, является очень низкой, но не нулевой. Это означает, что, хотя и очень маловероятно, но все же возможно, что сгенерируется структура, напоминающая пистолет, если мы генерируем достаточно большое количество случайных структур.

[MakarovDs]

Челендж пройти по мусору металлических обрубков вентиляционных труб

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

def generate_tube_field(shape, num_tubes, distance, outer_radius, inner_radius):
    array = np.zeros(shape, dtype=float)

    for i in range(num_tubes):
        # Определяем центр трубы
        x_center = (i % 8) * distance + distance // 2
        y_center = ((i // 8) % 8) * distance + distance // 2
        z_center = shape[2] // 2

        # Создание трубы
        for z in range(shape[2]):
            for angle in np.linspace(0, 2 * np.pi, 30):
                outer_x = int(x_center + outer_radius * np.cos(angle))
                outer_y = int(y_center + outer_radius * np.sin(angle))
                inner_x = int(x_center + inner_radius * np.cos(angle))
                inner_y = int(y_center + inner_radius * np.sin(angle))

                # Заполнение внешней части трубы
                if 0 <= outer_x < shape[0] and 0 <= outer_y < shape[1]:
                    array[outer_x, outer_y, z] = 1.0

                # Убираем внутреннюю часть
                if 0 <= inner_x < shape[0] and 0 <= inner_y < shape[1]:
                    array[inner_x, inner_y, z] = 0.0

    return array

shape = (64, 64, 64)
num_tubes = 100
distance = 10
outer_radius = 3  # Внешний радиус трубы
inner_radius = 2  # Внутренний радиус трубы

tube_field = generate_tube_field(shape, num_tubes, distance, outer_radius, inner_radius)

verts, faces, _, _ = measure.marching_cubes(tube_field, level=0.5)

# Удаляем внутренние грани из результата
verts = verts[verts[:, 2] > 0]
faces = faces[np.all(faces < len(verts), axis=1)]

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]} {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"Сохранено как {filename}")

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(verts[:, 0], verts[:, 1], verts[:, 2], color='blue', alpha=0.5)
plt.show()

и вот ещё кое что

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

def generate_tube_field(shape, num_tubes, tube_length, tube_radius):
    array = np.zeros(shape, dtype=float)
    x_positions = np.linspace(0, shape[0] - tube_radius, num_tubes // 2)
    y_positions = np.linspace(0, shape[1] - tube_radius, num_tubes // 2)
    z_position = shape[2] // 2
    for i in range(num_tubes // 2):
        for j in range(num_tubes // 2):
            x = x_positions[i]
            y = y_positions[j]
            for z in range(shape[2]):
                if 0 <= x < shape[0] and 0 <= y < shape[1] and 0 <= z < shape[2]:
                    # Создайте двумерную гауссову функцию для круглого поперечного сечения
                    xx, yy = np.meshgrid(np.arange(shape[0]) - x, np.arange(shape[1]) - y)
                    gaussian = (1 / (2 * np.pi * tube_radius ** 2)) * np.exp(-(xx ** 2 + yy ** 2) / (2 * tube_radius ** 2))
                    array[z, :, :] += gaussian
            # Добавить трубы в другом направлении
            x = y_positions[i]
            y = x_positions[j]
            for z in range(shape[2]):
                if 0 <= x < shape[0] and 0 <= y < shape[1] and 0 <= z < shape[2]:
                    # Создайте двумерную гауссову функцию для круглого поперечного сечения
                    xx, yy = np.meshgrid(np.arange(shape[0]) - x, np.arange(shape[1]) - y)
                    gaussian = (1 / (2 * np.pi * tube_radius ** 2)) * np.exp(-(xx ** 2 + yy ** 2) / (2 * tube_radius ** 2))
                    array[z, :, :] += gaussian
    return array

# Параметры
shape = (64, 64, 64)
num_tubes = 10
tube_length = 64
tube_radius = 3

# Создайте трехмерное поле с помощью круглых труб
tube_field = generate_tube_field(shape, num_tubes, tube_length, tube_radius)

# Создание изоповерхности из трехмерного поля
verts, faces, _, _ = measure.marching_cubes(tube_field, level=0.5 * np.max(tube_field))

# Сохраните изурфейса в OBJ-файл
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "round_tube.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], faces, verts[:, 2], color='r', alpha=0.5)
plt.show()