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

[MakarovDs]

Чисто куб

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

def generate_cube_field(shape):
    array = np.zeros(shape, dtype=float)
    # Создаем куб, заполняя массив значениями
    for x in range(shape[0]):
        for y in range(shape[1]):
            for z in range(shape[2]):
                # Преобразуем координаты в диапазон (-1, 1)
                xf = (x / shape[0]) * 2 - 1
                yf = (y / shape[1]) * 2 - 1
                zf = (z / shape[2]) * 2 - 1
                # Вычисляем значение куба
                if abs(xf) < 0.5 and abs(yf) < 0.5 and abs(zf) < 0.5:
                    value = 1.0
                else:
                    value = 0.0
                array[x, y, z] = value
    return array

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

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

# Создание куба
verts = np.array([
    [-1, -1, -1],
    [1, -1, -1],
    [1, 1, -1],
    [-1, 1, -1],
    [-1, -1, 1],
    [1, -1, 1],
    [1, 1, 1],
    [-1, 1, 1]
])

faces = np.array([
    [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]
])

# Сохранение куба в OBJ файл
mesh = trimesh.Trimesh(vertices=verts, faces=faces)
mesh.export("cube.obj")
# Параметры
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "cube.obj")

# Ви
# Сохранение изосурфейса в 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.scatter(verts[:, 0], verts[:, 1], verts[:, 2], color='r', alpha=0.5)
for face in faces:
    v1, v2, v3 = verts[face]
    ax.plot3D([v1[0], v2[0]], [v1[1], v2[1]], [v1[2], v2[2]], 'r', alpha=0.5)
    ax.plot3D([v2[0], v3[0]], [v2[1], v3[1]], [v2[2], v3[2]], 'r', alpha=0.5)
    ax.plot3D([v3[0], v1[0]], [v3[1], v1[1]], [v3[2], v1[2]], 'r', alpha=0.5)
plt.show()

[MakarovDs]

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

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

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

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

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

    return array

# Функция для генерации ромба в заданной точке
def generate_diamond(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):
            if abs(i) != abs(j):
                new_x, new_y, new_z = x + i, y + j, z
                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_sharp.obj")
with open(filename, "w") as f:
    for j, vert in enumerate(verts):
        f.write(f"v {vert[0]} {vert[1]} {vert[2]}\n")
    for face in faces:
        f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
print(f"Model saved as {filename}")

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

[MakarovDs]

ВОТ! Мы уже почти получили бэкрумс!

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

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

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

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

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

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

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

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

[MakarovDs]

���� ��������

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

# Генерация поверхности
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)
        for i in range(int(x.shape[0])):
            for j in range(int(x.shape[1])):
                if (x[i, j] - x_hole) ** 2 + (y[i, j] - y_hole) ** 2 <= radius ** 2:
                    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
    ax.plot_surface(x, y, np.full((y.shape[0], x.shape[1]), -depth), 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)):
            if z[i, j] < 0:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
            else:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
    for i in range(len(x) - 1):
        for j in range(len(y) - 1):
            if z[i, j] < 0 and z[i + 1, j] < 0 and z[i, j + 1] < 0 and z[i + 1, j + 1] < 0:
                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")
            elif z[i, j] >= 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")
            elif z[i, j] < 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")
            elif z[i, j] >= 0 and z[i + 1, j] < 0 and z[i, j + 1] < 0 and z[i + 1, j + 1] < 0:
                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")
    print(f"Файл сохранен как {filename}")

plt.show()

[MakarovDs]

Чисто плоскость

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

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

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

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

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

# Сохранение файла в OBJ
import os
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "surface.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")
    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")
print(f"Файл сохранен как {filename}")

plt.show()

[MakarovDs]

���� ����

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

# Генерация поверхности
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)
        for i in range(int(x.shape[0])):
            for j in range(int(x.shape[1])):
                if abs(x[i, j] - x_hole) <= radius and abs(y[i, j] - y_hole) <= radius:
                    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
    ax.plot_surface(x, y, np.full((y.shape[0], x.shape[1]), -depth), 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)):
            if z[i, j] < 0:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
            else:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
    for i in range(len(x) - 1):
        for j in range(len(y) - 1):
            if z[i, j] < 0 and z[i + 1, j] < 0 and z[i, j + 1] < 0 and z[i + 1, j + 1] < 0:
                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")
            elif z[i, j] >= 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")
            elif z[i, j] < 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")
            elif z[i, j] >= 0 and z[i + 1, j] < 0 and z[i, j + 1] < 0 and z[i + 1, j + 1] < 0:
                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")
    print(f"Файл сохранен как {filename}")

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)

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)

# Сохранение файла в 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)):
            if z[i, j] < 0:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
            else:
                f.write(f"v {x[i, j]} {y[i, j]} {z[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):
            if z[i, j] >= 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")

plt.show()

[MakarovDs]

решетка от грязи для обуви:

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

# Создание 3D-модели
mesh = trimesh.Trimesh(vertices=np.column_stack((x.flatten(), y.flatten(), z.flatten())), faces=np.array([(i, i+1, i+len(x)) for i in range(len(x)*len(y)-len(x))]))

# Экспорт 3D-модели в формат OBJ
mesh.export(os.path.join(os.path.expanduser("~"), "Desktop", 'urface_with_holes.obj'))

plt.show()

[MakarovDs]

Квадратноямие

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_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 = np.abs(z)

# Визуализируем только куб
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, 0, x_max-x_min, y_max-y_min, 5, color='r', alpha=0.5)

# Визуализируем куб
ax.bar3d(x.min(), y.min(), 0, x.max()-x.min(), y.max()-y.min(), 5, color='b', alpha=0.5)

# Сохранение файла в OBJ
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)):
            if z[i, j] < 5:
                f.write(f"v {x[i, j]} {y[i, j]} {z[i, j]}\n")
            else:
                f.write(f"v {x[i, j]} {y[i, j]} {z[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} {0}\n")
        f.write(f"v {x_max} {y_min} {0}\n")
        f.write(f"v {x_max} {y_max} {0}\n")
        f.write(f"v {x_min} {y_max} {0}\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):
            if z[i, j] >= 0 and z[i + 1, j] >= 0 and z[i, j + 1] >= 0 and z[i + 1, j + 1] >= 0:
                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")

plt.show()

[MakarovDs]

Странный откушенный куб.

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_cube(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny, nz):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    z = np.linspace(zmin, zmax, nz)
    x, y, z = np.meshgrid(x, y, z)
    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())
        z_hole = random.uniform(z.min(), z.max())
        radius = random.uniform(0.1, max_radius)
        depth = random.uniform(0, max_depth)

        # Создайте сферическое отверстие с заданным радиусом и глубиной
        x_hole_grid, y_hole_grid, z_hole_grid = np.meshgrid(
            np.linspace(x_hole - radius, x_hole + radius, 100),
            np.linspace(y_hole - radius, y_hole + radius, 100),
            np.linspace(z_hole - radius, z_hole + radius, 100)
        )
        mask = (x_hole_grid**2 + y_hole_grid**2 + z_hole_grid**2 <= radius**2)

        # Вырежьте отверстия в кубе
        x[mask] = np.nan
        y[mask] = np.nan
        z[mask] = np.nan

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

    return x, y, z, holes

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

x, y, z = generate_cube(-5, 5, -5, 5, -5, 5, 100, 100, 100)
x, y, z, holes = create_holes(x, y, z, 2, 2)

# Удалите значения NaN (отверстия) из визуализации
x = np.nan_to_num(x)
y = np.nan_to_num(y)
z = np.nan_to_num(z)

# Визуализируйте куб с отверстиями
ax.scatter(x, y, z, c='b', alpha=0.5)

# Визуализируйте отверстия
for hole in holes:
    x_hole, y_hole, z_hole, radius, depth = hole
    ax.scatter(x_hole, y_hole, z_hole, c='r', s=radius*100, alpha=0.5)

#Сохраните файл в формате OBJ
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "cube_with_holes.obj")
with open(filename, "w") as f:
    f.write("# cube_with_holes.obj\n")
    for i in range(len(x)):
        for j in range(len(y)):
            for k in range(len(z)):
                if not np.isnan(x[i, j, k]):
                    f.write(f"v {x[i, j, k]} {y[i, j, k]} {z[i, j, k]}\n")
    for i in range(len(x) - 1):
        for j in range(len(y) - 1):
            for k in range(len(z) - 1):
                if not np.isnan(x[i, j, k]) and not np.isnan(x[i + 1, j, k]) and not np.isnan(x[i, j + 1, k]) and not np.isnan(x[i, j, k + 1]):
                    f.write(f"f {i * len(y) * len(z) + j * len(z) + k + 1} {(i + 1) * len(y) * len(z) + j * len(z) + k + 1} {(i + 1) * len(y) * len(z) + (j + 1) * len(z) + k + 1}\n")
                    f.write(f"f {i * len(y) * len(z) + j * len(z) + k + 1} {(i + 1) * len(y) * len(z) + (j + 1) * len(z) + k + 1} {i * len(y) * len(z) + (j + 1) * len(z) + k + 1}\n")

plt.show()