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

[MakarovDs]

Изурфейсный лабиринт

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from skimage import measure
import os
def generate_hair_surface(shape, hair_length, hair_density):
    # Создаем 3D массив для поверхности
    surface = np.zeros(shape, dtype=float)

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

    return surface

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

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

    return surface

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

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

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

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

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

Напомнило мне локацию в unreal tournament 3 где была такая египетская локация с двумя I-образная входами, и выходами. И любил там генерировать кучу ботов.

[MakarovDs]

Сломанный динамик трубами.

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

# Генерация поверхности
def generate_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.sin(np.sqrt(X**2 + Y**2))
    return X, Y, Z

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
    ax.plot(hair_x, hair_y, hair_z, 'b-')
    plt.show()

# Генерация волос
def generate_hair(X, Y, Z, num_hairs, length, radius):
    hair_x = []
    hair_y = []
    hair_z = []
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            if np.random.rand() < 0.1:  # вероятность появления волоса
                theta = np.linspace(0, 2 * np.pi, 10)
                for k in range(length):
                    for t in theta:
                        hair_x.append(X[i, j] + radius * np.cos(t))
                        hair_y.append(Y[i, j] + radius * np.sin(t))
                        hair_z.append(Z[i, j] + k * 0.1)
    return hair_x, hair_y, hair_z

# Сохранение файла
def save_file(X, Y, Z, hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "surface_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                f.write(f"v {X[i, j]} {Y[i, j]} {Z[i, j]}\n")
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_y[i]} {hair_z[i]}\n")
        for i in range(X.shape[0] - 1):
            for j in range(X.shape[1] - 1):
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2}\n")
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2} {i * X.shape[1] + j + 2}\n")
        num_hairs = len(hair_x) // 10 // 10
        for i in range(num_hairs):
            for j in range(10):
                for k in range(10):
                    idx1 = i * 10 * 10 + j * 10 + k
                    idx2 = i * 10 * 10 + j * 10 + (k + 1) % 10
                    idx3 = (i * 10 * 10 + (j + 1) * 10 + (k + 1) % 10)
                    idx4 = (i * 10 * 10 + (j + 1) * 10 + k)
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx2 + 1} {X.shape[0] * X.shape[1] + idx3 + 1}\n")
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx3 + 1} {X.shape[0] * X.shape[1] + idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    X, Y, Z = generate_surface(-10, 10, -10, 10, -10, 10, 100, 100)
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, 100, 10, 0.1)
    save_file(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

Поле сломанных труб

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

# Генерация поверхности
def generate_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.sin(np.sqrt(X**2 + Y**2))
    return X, Y, Z

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
    ax.plot(hair_x, hair_y, hair_z, 'b-')
    plt.show()

# Генерация поверхности кожи
def generate_skin_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.ones(X.shape) * zmin
    return X, Y, Z

# Генерация волос
def generate_hair(X, Y, Z, num_hairs, length, radius):
    hair_x = []
    hair_y = []
    hair_z = []
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            if np.random.rand() < 0.1:  # вероятность появления волоса
                theta = np.linspace(0, 2 * np.pi, 10)
                for k in range(length):
                    for t in theta:
                        hair_x.append(X[i, j] + radius * np.cos(t))
                        hair_y.append(Y[i, j] + radius * np.sin(t))
                        hair_z.append(Z[i, j] + k * 0.1)
    return hair_x, hair_y, hair_z

# Сохранение файла
def save_file(X, Y, Z, hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "skin_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                f.write(f"v {X[i, j]} {Y[i, j]} {Z[i, j]}\n")
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_y[i]} {hair_z[i]}\n")
        for i in range(X.shape[0] - 1):
            for j in range(X.shape[1] - 1):
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2}\n")
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2} {i * X.shape[1] + j + 2}\n")
        num_hairs = len(hair_x) // 10 // 10
        for i in range(num_hairs):
            for j in range(10):
                for k in range(10):
                    idx1 = i * 10 * 10 + j * 10 + k
                    idx2 = i * 10 * 10 + j * 10 + (k + 1) % 10
                    idx3 = (i * 10 * 10 + (j + 1) * 10 + (k + 1) % 10)
                    idx4 = (i * 10 * 10 + (j + 1) * 10 + k)
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx2 + 1} {X.shape[0] * X.shape[1] + idx3 + 1}\n")
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx3 + 1} {X.shape[0] * X.shape[1] + idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    X, Y, Z = generate_skin_surface(-10, 10, -10, 10, -10, 10, 100, 100)
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, 100, 10, 0.1)
    save_file(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

Изломанная дверь

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

# Генерация поверхности
def generate_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.sin(np.sqrt(X**2 + Y**2))
    return X, Y, Z

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
    ax.plot(hair_x, hair_y, hair_z, 'b-')
    plt.show()
# Генерация волос
def generate_hair(num_hairs, length, radius):
    hair_x = []
    hair_y = []
    hair_z = []
    for _ in range(num_hairs):
        x = np.random.uniform(-10, 10)
        y = np.random.uniform(-10, 10)
        z = 0
        theta = np.linspace(0, 2 * np.pi, 10)
        for k in range(length):
            for t in theta:
                hair_x.append(x + radius * np.cos(t) + np.random.uniform(-0.1, 0.1))
                hair_y.append(y + radius * np.sin(t) + np.random.uniform(-0.1, 0.1))
                hair_z.append(z + k * 0.1)
    return hair_x, hair_y, hair_z

def is_intersecting(hair_x, hair_y, hair_z, new_x, new_y, new_z, radius):
    for i in range(len(hair_x)):
        dx = hair_x[i] - new_x
        dy = hair_y[i] - new_y
        dz = hair_z[i] - new_z
        distance = np.sqrt(dx**2 + dy**2 + dz**2)
        if distance < 2 * radius:
            return True
    return False

# Генерация волос
def generate_hair(num_hairs, length, radius):
    hair_x = []
    hair_y = []
    hair_z = []
    for _ in range(num_hairs):
        x = np.random.uniform(-10, 10)
        y = np.random.uniform(-10, 10)
        z = 0
        theta = np.linspace(0, 2 * np.pi, 10)
        for k in range(length):
            for t in theta:
                new_x = x + radius * np.cos(t) + np.random.uniform(-0.1, 0.1)
                new_y = y + radius * np.sin(t) + np.random.uniform(-0.1, 0.1)
                new_z = z + k * 0.1
                if not is_intersecting(hair_x, hair_y, hair_z, new_x, new_y, new_z, radius):
                    hair_x.append(new_x)
                    hair_y.append(new_y)
                    hair_z.append(new_z)
    return hair_x, hair_y, hair_z

# Сохранение файла
def save_file(hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "hair.obj")
    with open(filename, "w") as f:
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_y[i]} {hair_z[i]}\n")
        num_hairs = len(hair_x) // 10 // 10
        for i in range(num_hairs):
            for j in range(10):
                for k in range(10):
                    idx1 = i * 10 * 10 + j * 10 + k
                    idx2 = i * 10 * 10 + j * 10 + (k + 1) % 10
                    idx3 = (i * 10 * 10 + (j + 1) * 10 + (k + 1) % 10)
                    idx4 = (i * 10 * 10 + (j + 1) * 10 + k)
                    f.write(f"f {idx1 + 1} {idx2 + 1} {idx3 + 1}\n")
                    f.write(f"f {idx1 + 1} {idx3 + 1} {idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    hair_x, hair_y, hair_z = generate_hair(100, 10, 0.1)
    save_file(hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

Лентикулярная печать

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

# Генерация поверхности кожи
def generate_skin_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.ones(X.shape) * zmin
    return X, Y, Z

# Генерация волос
def generate_hair(X, Y, Z, num_hairs, length, radius):
    hair_x = []
    hair_y = []
    hair_z = []
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            if np.random.rand() < 0.1:  # вероятность появления волоса
                for k in range(length):
                    hair_x.append(X[i, j])
                    hair_y.append(Y[i, j])
                    hair_z.append(Z[i, j] + k * 0.1)
    return hair_x, hair_y, hair_z

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
    ax.plot(hair_x, hair_y, hair_z, 'b-', linewidth=2)
    plt.show()

# Сохранение файла
def save_file(X, Y, Z, hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "skin_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                f.write(f"v {X[i, j]} {Y[i, j]} {Z[i, j]}\n")
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_y[i]} {hair_z[i]}\n")
        for i in range(X.shape[0] - 1):
            for j in range(X.shape[1] - 1):
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2}\n")
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2} {i * X.shape[1] + j + 2}\n")
        num_hairs = len(hair_x) // 10 // 10
        for i in range(num_hairs):
            for j in range(10):
                for k in range(10):
                    idx1 = i * 10 * 10 + j * 10 + k
                    idx2 = i * 10 * 10 + j * 10 + (k + 1) % 10
                    idx3 = (i * 10 * 10 + (j + 1) * 10 + (k + 1) % 10)
                    idx4 = (i * 10 * 10 + (j + 1) * 10 + k)
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx2 + 1} {X.shape[0] * X.shape[1] + idx3 + 1}\n")
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx3 + 1} {X.shape[0] * X.shape[1] + idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    X, Y, Z = generate_skin_surface(-10, 10, -10, 10, -10, 10, 100, 100)
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, 100, 10, 0.1)
    visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z)
    save_file(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

Лес сломанных труб

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

# Генерация поверхности кожи
def generate_skin_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.ones(X.shape) * zmin
    return X, Y, Z

# Генерация волос
def generate_hair(X, Y, Z, num_hairs, length, radius, wave_amplitude=0.5, wave_frequency=0.1):
    hair_x = []
    hair_y = []
    hair_z = []
    for _ in range(num_hairs):
        i, j = np.random.randint(0, X.shape[0], size=2)
        theta = np.linspace(0, 2 * np.pi, 10)
        for k in range(length):
            z = Z[i, j] + k * 0.1 + wave_amplitude * np.sin(k * wave_frequency)  
            for t in theta:
                hair_x.append(X[i, j] + radius * np.cos(t))
                hair_y.append(Y[i, j] + radius * np.sin(t))
                hair_z.append(z)
    return hair_x, hair_y, hair_z

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)
    ax.plot(hair_x, hair_y, hair_z, 'b-', linewidth=2)
    plt.show()

# Сохранение файла
def save_file(X, Y, Z, hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "skin_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                f.write(f"v {X[i, j]} {Y[i, j]} {Z[i, j]}\n")
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_y[i]} {hair_z[i]}\n")
        for i in range(X.shape[0] - 1):
            for j in range(X.shape[1] - 1):
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2}\n")
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2} {i * X.shape[1] + j + 2}\n")
        num_hairs = len(hair_x) // 10 // 10
        for i in range(num_hairs):
            for j in range(10):
                for k in range(10):
                    idx1 = i * 10 * 10 + j * 10 + k
                    idx2 = i * 10 * 10 + j * 10 + (k + 1) % 10
                    idx3 = (i * 10 * 10 + (j + 1) * 10 + (k + 1) % 10)
                    idx4 = (i * 10 * 10 + (j + 1) * 10 + k)
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx2 + 1} {X.shape[0] * X.shape[1] + idx3 + 1}\n")
                    f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx3 + 1} {X.shape[0] * X.shape[1] + idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    X, Y, Z = generate_skin_surface(-10, 10, -10, 10, -10, 10, 100, 100)
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, 100, 10, 0.1)
    visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z)
    save_file(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

Минимонтолизм

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import random
from scipy.interpolate import interp1d
import os

# Генерация поверхности кожи
def generate_skin_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.ones(X.shape) * zmin
    return X, Y, Z

def generate_hair(X, Y, Z, num_hairs, hair_length, hair_radius):
    hair_x_tube = []
    hair_y_tube = []
    hair_z_tube = []

    for _ in range(num_hairs):
        hair_x = np.random.uniform(X.min(), X.max())
        hair_y = np.random.uniform(Y.min(), Y.max())
        hair_z = Z.min()

        hair_t = np.linspace(0, 1, 100)
        hair_x_interp = np.linspace(hair_x, hair_x, 100)
        hair_y_interp = np.linspace(hair_y, hair_y, 100)
        hair_z_interp = np.linspace(hair_z, hair_z + hair_length, 100)

        hair_theta = np.linspace(0, 2*np.pi, 100)

        hair_x_tube_local = []
        hair_y_tube_local = []
        hair_z_tube_local = []

        for i in range(len(hair_x_interp)):
            for j in range(len(hair_theta)):
                hair_x_tube_local.append(hair_x_interp[i] + hair_radius * np.cos(hair_theta[j]))
                hair_y_tube_local.append(hair_y_interp[i] + hair_radius * np.sin(hair_theta[j]))
                hair_z_tube_local.append(hair_z_interp[i])

        hair_x_tube.extend(hair_x_tube_local)
        hair_y_tube.extend(hair_y_tube_local)
        hair_z_tube.extend(hair_z_tube_local)

        # Добавить пустые значения для разделения труб
        hair_x_tube.extend([np.nan]*len(hair_theta))
        hair_y_tube.extend([np.nan]*len(hair_theta))
        hair_z_tube.extend([np.nan]*len(hair_theta))

    return hair_x_tube, hair_y_tube, hair_z_tube

# Визуализация поверхности и волос
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.5)

    num_hairs = len(hair_x) // 100
    for i in range(num_hairs):
        hair_x_local = hair_x[i*100:(i+1)*100]
        hair_y_local = hair_y[i*100:(i+1)*100]
        hair_z_local = hair_z[i*100:(i+1)*100]
        ax.plot(hair_x_local, hair_y_local, hair_z_local, 'k-')

    plt.show()

# Сохранение файла
def save_file(X, Y, Z, hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "skin_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(X.shape[0]):
            for j in range(X.shape[1]):
                f.write(f"v {X[i, j]} {Z[i, j]} {Y[i, j]}\n")
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_z[i]} {hair_y[i]}\n")
        for i in range(X.shape[0] - 1):
            for j in range(X.shape[1] - 1):
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2}\n")
                f.write(f"f {i * X.shape[1] + j + 1} {(i + 1) * X.shape[1] + j + 2} {i * X.shape[1] + j + 2}\n")
        num_hairs = len(hair_x) // 100
        for i in range(num_hairs):
            for j in range(100):
                idx1 = i * 100 + j
                idx2 = i * 100 + (j + 1) % 100
                idx3 = (i + 1) * 100 + (j + 1) % 100
                idx4 = (i + 1) * 100 + j

                f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx2 + 1} {X.shape[0] * X.shape[1] + idx3 + 1}\n")
                f.write(f"f {X.shape[0] * X.shape[1] + idx1 + 1} {X.shape[0] * X.shape[1] + idx3 + 1} {X.shape[0] * X.shape[1] + idx4 + 1}\n")
    print(f"Файл сохранен как {filename}")

# Основная функция
def main():
    X, Y, Z = generate_skin_surface(-10, 10, -10, 10, 0, 10, 100, 100)
    num_hairs = random.randint(3, 120)
    hair_length = 5
    hair_radius = 0.1
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, num_hairs, hair_length, hair_radius)
    visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z)
    save_file(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[MakarovDs]

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

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import random
from scipy.interpolate import interp1d
import os

# Генерация поверхности кожи
def generate_skin_surface(xmin, xmax, ymin, ymax, zmin, zmax, nx, ny):
    x = np.linspace(xmin, xmax, nx)
    y = np.linspace(ymin, ymax, ny)
    X, Y = np.meshgrid(x, y)
    Z = np.ones(X.shape) * zmin
    return X, Y, Z
def visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')

    num_hairs = len(hair_x) // 100
    for i in range(num_hairs):
        hair_x_local = hair_x[i*100:(i+1)*100]
        hair_y_local = hair_y[i*100:(i+1)*100]
        hair_z_local = hair_z[i*100:(i+1)*100]
        ax.plot(hair_x_local, hair_y_local, hair_z_local, 'k-', marker='o', markersize=2)

    plt.show()
def generate_hair(X, Y, Z, num_hairs, hair_length, hair_radius):
    hair_x_tube = []
    hair_y_tube = []
    hair_z_tube = []

    for _ in range(num_hairs):
        hair_x = np.random.uniform(X.min(), X.max())
        hair_y = np.random.uniform(Y.min(), Y.max())
        hair_z = Z.max() + np.random.uniform(0, hair_length)

        hair_t = np.linspace(0, 1, 100)
        hair_x_interp = np.linspace(hair_x, hair_x, 100)
        hair_y_interp = np.linspace(hair_y, hair_y, 100)
        hair_z_interp = np.linspace(hair_z - hair_length, hair_z, 100)

        hair_theta = np.linspace(0, 2*np.pi, 100)

        hair_x_tube_local = []
        hair_y_tube_local = []
        hair_z_tube_local = []

        for i in range(len(hair_x_interp)):
            for j in range(len(hair_theta)):
                hair_x_tube_local.append(hair_x_interp[i] + hair_radius * np.cos(hair_theta[j]))
                hair_y_tube_local.append(hair_y_interp[i] + hair_radius * np.sin(hair_theta[j]))
                hair_z_tube_local.append(hair_z_interp[i])

        hair_x_tube.extend(hair_x_tube_local)
        hair_y_tube.extend(hair_y_tube_local)
        hair_z_tube.extend(hair_z_tube_local)

        # Добавить пустые значения для разделения труб
        hair_x_tube.extend([np.nan]*len(hair_theta))
        hair_y_tube.extend([np.nan]*len(hair_theta))
        hair_z_tube.extend([np.nan]*len(hair_theta))

    return hair_x_tube, hair_y_tube, hair_z_tube

# Сохранение файла
def save_file(hair_x, hair_y, hair_z):
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, "skin_and_hair.obj")
    with open(filename, "w") as f:
        for i in range(len(hair_x)):
            f.write(f"v {hair_x[i]} {hair_z[i]} {hair_y[i]}\n")
        num_hairs = len(hair_x) // 100
        for i in range(num_hairs):
            for j in range(100):
                idx1 = i * 100 + j
                idx2 = i * 100 + (j + 1) % 100
                idx3 = (i + 1) * 100 + (j + 1) % 100
                idx4 = (i + 1) * 100 + j

                f.write(f"f {idx1 + 1} {idx2 + 1} {idx3 + 1}\n")
                f.write(f"f {idx1 + 1} {idx3 + 1} {idx4 + 1}\n")

# Основная функция
def main():
    X, Y, Z = generate_skin_surface(-10, 10, -10, 10, 0, 10, 100, 100)
    num_hairs = random.randint(3, 120)
    hair_length = 5
    hair_radius = 0.1
    hair_x, hair_y, hair_z = generate_hair(X, Y, Z, num_hairs, hair_length, hair_radius)
    save_file(hair_x, hair_y, hair_z)
    visualize_surface_and_hair(X, Y, Z, hair_x, hair_y, hair_z)

if __name__ == "__main__":
    main()

[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_field(shape, num_hairs, hair_length, hair_radius):
    array = np.zeros(shape, dtype=float)
    for _ in range(num_hairs):
        x, y, z = np.random.randint(0, shape[0]), np.random.randint(0, shape[1]), np.random.randint(0, shape[2])
        for _ in range(hair_length):
            dx = np.random.randint(-1, 2)
            dy = np.random.randint(-1, 2)
            dz = np.random.randint(1, 3)
            x += dx
            y += dy
            z += dz
            if 0 <= x < shape[0] and 0 <= y < shape[1] and 0 <= z < shape[2]:
                array[x, y, z] = 1.0
                # Делаем волосы более жирными
                if x > 0:
                    array[x-1, y, z] = 1.0
                if x < shape[0] - 1:
                    array[x+1, y, z] = 1.0
                if y > 0:
                    array[x, y-1, z] = 1.0
                if y < shape[1] - 1:
                    array[x, y+1, z] = 1.0
                if z > 0:
                    array[x, y, z-1] = 1.0
                if z < shape[2] - 1:
                    array[x, y, z+1] = 1.0
    return array

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
num_hairs = 100  # Количество волос
hair_length = 20  # Длина волос
hair_radius = 1  # Радиус волос

# Генерация 3D-поля с волосами
hair_field = generate_hair_field(shape, num_hairs, hair_length, hair_radius)

# Создание изосурфейса из 3D-поля
verts, faces, _, _ = measure.marching_cubes(hair_field, level=0.5)

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

def generate_hair_field(shape, num_hairs, hair_length, hair_radius):
    array = np.zeros(shape, dtype=float)
    for _ in range(num_hairs):
        x, y, z = np.random.randint(0, shape[0]), np.random.randint(0, shape[1]), np.random.randint(0, shape[2])
        for _ in range(hair_length):
            dx = np.random.randint(-1, 2)
            dy = np.random.randint(-1, 2)
            dz = np.random.randint(1, 3)
            x += dx
            y += dy
            z += dz
            if 0 <= x < shape[0] and 0 <= y < shape[1] and 0 <= z < shape[2]:
                array[x, y, z] = 1.0
                # Делаем волосы более жирными
                if x > 0:
                    array[x-1, y, z] = 1.0
                if x < shape[0] - 1:
                    array[x+1, y, z] = 1.0
                if y > 0:
                    array[x, y-1, z] = 1.0
                if y < shape[1] - 1:
                    array[x, y+1, z] = 1.0
                if z > 0:
                    array[x, y, z-1] = 1.0
                if z < shape[2] - 1:
                    array[x, y, z+1] = 1.0
    return array

# Параметры
shape = (64, 64, 64)  # Размеры 3D массива
num_hairs = 100  # Количество волос
hair_length = 20  # Длина волос
hair_radius = 1  # Радиус волос

# Генерация 3D-поля с волосами
hair_field = generate_hair_field(shape, num_hairs, hair_length, hair_radius)

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

points = []
for i in range(shape[0]):
    for j in range(shape[1]):
        for k in range(shape[2]):
            if hair_field[i, j, k] == 1.0:
                points.append([i, j, k])

# Интерполяция
t = np.linspace(0, 1, len(points))
x = np.array([point[0] for point in points])
y = np.array([point[1] for point in points])
z = np.array([point[2] for point in points])

x_interp = interp1d(t, x, kind='cubic')
y_interp = interp1d(t, y, kind='cubic')
z_interp = interp1d(t, z, kind='cubic')

t_interp = np.linspace(0, 1, 1000)
x_interp = x_interp(t_interp)
y_interp = y_interp(t_interp)
z_interp = z_interp(t_interp)

ax.plot(x_interp, y_interp, z_interp, 'b-')

ax.scatter(*zip(*points))

# Генерация трубок
radius = 1.0
theta = np.linspace(0, 2*np.pi, 100)

tube_x = []
tube_y = []
tube_z = []

for i in range(num_hairs):
    x_hair = np.array([point[0] for point in points if point[2] == i])
    y_hair = np.array([point[1] for point in points if point[2] == i])
    z_hair = np.array([point[2] for point in points if point[2] == i])

    if len(x_hair) < 4:
        continue

    x_hair_interp = interp1d(np.linspace(0, 1, len(x_hair)), x_hair, kind='linear')
    y_hair_interp = interp1d(np.linspace(0, 1, len(y_hair)), y_hair, kind='linear')
    z_hair_interp = interp1d(np.linspace(0, 1, len(z_hair)), z_hair, kind='linear')

    t_hair_interp = np.linspace(0, 1, 100)
    x_hair_interp = x_hair_interp(t_hair_interp)
    y_hair_interp = y_hair_interp(t_hair_interp)
    z_hair_interp = z_hair_interp(t_hair_interp)

    for j in range(len(x_hair_interp)):
        for k in range(len(theta)):
            tube_x.append(x_hair_interp[j] + radius * np.cos(theta[k]))
            tube_y.append(y_hair_interp[j] + radius * np.sin(theta[k]))
            tube_z.append(z_hair_interp[j])

# Создание вершин и треугольников для меша
vertices = []
faces = []

tube_idx = 0
for i in range(len(x_hair_interp) - 1):
    for j in range(num_hairs):
        tube_x_section = []
        tube_y_section = []
        tube_z_section = []
        for k in range(len(theta)):
            if tube_idx + k < len(tube_x):
                tube_x_section.append(tube_x[tube_idx + k])
                tube_y_section.append(tube_y[tube_idx + k])
                tube_z_section.append(tube_z[tube_idx + k])
        tube_idx += len(theta)

        for k in range(len(theta) - 1):
            if tube_idx - len(theta) + k < len(tube_x) and tube_idx - len(theta) + k + 1 < len(tube_x) and tube_idx - len(theta) + k + len(theta) < len(tube_x) and tube_idx - len(theta) + k + len(theta) + 1 < len(tube_x):
                vertices.append([tube_x[tube_idx - len(theta) + k], tube_y[tube_idx - len(theta) + k], tube_z[tube_idx - len(theta) + k]])
                vertices.append([tube_x[tube_idx - len(theta) + k + 1], tube_y[tube_idx - len(theta) + k + 1], tube_z[tube_idx - len(theta) + k + 1]])
                vertices.append([tube_x[tube_idx - len(theta) + k], tube_y[tube_idx - len(theta) + k], tube_z[tube_idx - len(theta) + k] + 1])
                vertices.append([tube_x[tube_idx - len(theta) + k + 1], tube_y[tube_idx - len(theta) + k + 1], tube_z[tube_idx - len(theta) + k + 1] + 1])

                faces.append([tube_idx - len(theta) + k, tube_idx - len(theta) + k + 1, tube_idx - len(theta) + k + len(theta)])
                faces.append([tube_idx - len(theta) + k + 1, tube_idx - len(theta) + k + len(theta), tube_idx - len(theta) + k + len(theta) + 1])

# Сохранение меша в файл
import os
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
filename = os.path.join(desktop_path, "tubes.obj")
with open(filename, "w") as f:
    for i, vertex in enumerate(vertices):
        f.write(f"v {vertex[0]} {vertex[1]} {vertex[2]}\n")
    for face in faces:
        f.write(f"f {face[0] + 1} {face[1] + 1} {face[2] + 1}\n")
print(f"Tubes saved as {filename}")

# Визуализация меша
from mpl_toolkits.mplot3d.art3d import Poly3DCollection

mesh = Poly3DCollection(vertices, facecolors='b', alpha=0.5)
ax.add_collection3d(mesh)

plt.show()