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

[MakarovDs]

Получилось ещё хуже но это можно использовать как какие нибудь глючные объекты для какого нибудь уровня бэкрумс:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from scipy.spatial import Delaunay
import os

def save_model(verts, faces, filename):
    try:
        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))
        print(f"Model saved as {filename}")
    except Exception as e:
        print(f"Error saving model: {e}")

# Функция для генерации кадра
def update(ax):
    ax.clear()  # Очистка текущего окна

    # Генерация точек
    points = []
    for i in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

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

    # Выполнить триангуляцию Делоне
    triangulation = Delaunay(points)

    # Постройте график треугольников
    for triangle in triangulation.simplices:
        ax.plot3D(points[triangle, 0], points[triangle, 1], points[triangle, 2], 'k-', linewidth=1)

# Генерация точек
points = []
for i in range(100):
    x = np.random.uniform(-100, 100)
    y = np.random.uniform(-100, 100)
    z = np.random.uniform(-100, 100)
    points.append([x, y, z])

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

# Выполнить триангуляцию Делоне
triangulation = Delaunay(points)

# Сохранение модели в формате OBJ
output_path = os.path.join(os.path.expanduser('~'), 'Desktop', 'odel.obj')
save_model(points, triangulation.simplices, output_path)

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

# Визуализация модели
for triangle in triangulation.simplices:
    verts = points[triangle]
    poly3d = Poly3DCollection([verts], alpha=0.5, edgecolor='k')
    ax.add_collection3d(poly3d)

# Настройки отображения
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

# Показываем окно с моделью
plt.show()

# Сохранение модели в формате OBJ
output_path = os.path.join(os.path.expanduser('~'), 'Desktop', 'odel.obj')
with open(output_path, 'w') as f:
    for triangle in triangulation.simplices:
        verts = points[triangle]
        for v in verts:
            f.write('v {:.6f} {:.6f} {:.6f}\n'.format(v[0], v[1], v[2]))
        f.write('f')
        for v in verts:
            f.write(' {}'.format(v[0]+1))
        f.write('\n')

[MakarovDs]

Вооооо пошла жара!

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

# Функция для генерации кадра
def update(ax):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for i in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    for i in range(len(points) - 1):
        ax.plot([points[i][0], points[i+1][0]], [points[i][1], points[i+1][1]], [points[i][2], points[i+1][2]], 'b-', linewidth=5)

    return points

# Функция для сохранения ломаной линии в файл OBJ
def save_to_obj(points, filename):
    with open(filename, 'w') as f:
        for i, point in enumerate(points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for i in range(len(points) - 1):
            f.write(f"l {i+1} {i+2}\n")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    points = update(ax)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

    # Сохраняем каждый кадр в файл OBJ
    filename = os.path.join(os.path.expanduser("~"), "Desktop", f"lomannaya_linia_{i+1}.obj")
    save_to_obj(points, filename)
    time.sleep(0.01)  # Пауза перед сохранением файла
    print(f"Model saved as {filename}")

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

Теперь генерируется линия, и осталось лишь превратить её в изурфейс.

[MakarovDs]

А это вообще что непонятно...

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

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for j in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    # Создание трубки
    tube_points = []
    tube_faces = []
    for j in range(len(points) - 1):
        x1, y1, z1 = points[j]
        x2, y2, z2 = points[j+1]
        vec = np.array([x2-x1, y2-y1, z2-z1])
        vec = vec / np.linalg.norm(vec)
        perp_vec1 = np.array([vec[1], -vec[0], 0])
        perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
        perp_vec2 = np.cross(vec, perp_vec1)
        perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
        radius = 5
        num_points = 10
        angles = np.linspace(0, 2*np.pi, num_points)
        for angle in angles:
            pos = np.array([x1, y1, z1]) + radius * (np.cos(angle) * perp_vec1 + np.sin(angle) * perp_vec2)
            tube_points.append(pos.tolist())
            if angle!= 2*np.pi:
                tube_faces.append([len(tube_points)-1, len(tube_points)-2, len(tube_points)])
                tube_faces.append([len(tube_points)-2, len(tube_points)-1, len(tube_points)])

    # Отрисовка трубки
    for j in range(len(tube_points) - 1):
        ax.plot3D(*zip(tube_points[j], tube_points[j+1]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for face in tube_faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
    print(f"Model saved as {filename}")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

Теперь получились рванные трубы

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

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for j in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    # Создание трубки
    tube_points = []
    tube_faces = []
    for j in range(len(points) - 1):
        x1, y1, z1 = points[j]
        x2, y2, z2 = points[j+1]
        vec = np.array([x2-x1, y2-y1, z2-z1])
        vec = vec / np.linalg.norm(vec)
        perp_vec1 = np.array([vec[1], -vec[0], 0])
        perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
        perp_vec2 = np.cross(vec, perp_vec1)
        perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
        radius = 5
        num_points = 10
        angles = np.linspace(0, 2*np.pi, num_points)
        for k in range(num_points):
            pos1 = np.array([x1, y1, z1]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            pos2 = np.array([x2, y2, z2]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            tube_points.append(pos1.tolist())
            tube_points.append(pos2.tolist())
            tube_faces.append([len(tube_points)-2, len(tube_points)-1, len(tube_points)])
            tube_faces.append([len(tube_points)-1, len(tube_points)-2, len(tube_points)])

    # Отрисовка трубки
    for j in range(len(tube_points) - 1):
        ax.plot3D(*zip(tube_points[j], tube_points[j+1]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for face in tube_faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
    print(f"Model saved as {filename}")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

А это вообще свалка труб:

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

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for j in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    # Создание трубки
    tube_points = []
    tube_faces = []
    for j in range(len(points) - 1):
        x1, y1, z1 = points[j]
        x2, y2, z2 = points[j+1]
        vec = np.array([x2-x1, y2-y1, z2-z1])
        vec = vec / np.linalg.norm(vec)
        perp_vec1 = np.array([vec[1], -vec[0], 0])
        perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
        perp_vec2 = np.cross(vec, perp_vec1)
        perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
        radius = 5
        num_points = 10
        angles = np.linspace(0, 2*np.pi, num_points)
        for k in range(num_points):
            pos1 = np.array([x1, y1, z1]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            pos2 = np.array([x2, y2, z2]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            tube_points.append(pos1.tolist())
            tube_points.append(pos2.tolist())
            if k < num_points - 1:
                tube_faces.append([len(tube_points)-2, len(tube_points)-1, len(tube_points)])
                tube_faces.append([len(tube_points)-1, len(tube_points)-2, len(tube_points)])
            else:
                tube_faces.append([len(tube_points)-2, len(tube_points)-1, 0])
                tube_faces.append([len(tube_points)-1, len(tube_points)-2, 0])

    # Отрисовка трубки
    for j in range(len(tube_points) - 1):
        ax.plot3D(*zip(tube_points[j], tube_points[j+1]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for face in tube_faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
    print(f"Model saved as {filename}")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

В бассейне полного разбитого стеклалалааааааааа, ставлю рекорды на скорость и глубинунуну нанана...

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

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for j in range(100):
        x = np.random.uniform(-100, 100)
        y = np.random.uniform(-100, 100)
        z = np.random.uniform(-100, 100)
        points.append([x, y, z])

    # Создание трубки
    tube_points = []
    tube_faces = []
    for j in range(len(points) - 1):
        x1, y1, z1 = points[j]
        x2, y2, z2 = points[j+1]
        vec = np.array([x2-x1, y2-y1, z2-z1])
        vec = vec / np.linalg.norm(vec)
        perp_vec1 = np.array([vec[1], -vec[0], 0])
        perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
        perp_vec2 = np.cross(vec, perp_vec1)
        perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
        radius = 5
        num_points = 20
        t = np.linspace(0, 1, num_points + 1)
        for k in range(num_points):
            t1 = t[k]
            t2 = t[k+1]
            pos = (1-t1)**3 * np.array([x1, y1, z1]) + 3*(1-t1)**2*t1 * np.array([x1, y1, z1]) + 3*(1-t1)*t1**2 * np.array([x2, y2, z2]) + t1**3 * np.array([x2, y2, z2])
            tube_points.append(pos.tolist())
            if k > 0 and k < num_points - 1:
                face = [
                    len(tube_points) - 1,  # текущая вершина
                    len(tube_points) - 2,  # предыдущая вершина
                    len(tube_points) - 3,  # предыдущая вершина на предыдущем сегменте
                    len(tube_points) - 4   # предыдущая вершина на следующем сегменте
                ]
                tube_faces.append(face)

    # Отрисовка трубки
    for j in range(len(tube_points) - 1):
        ax.plot3D(*zip(tube_points[j], tube_points[j+1]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for face in tube_faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1} {face[3]+1}\n")
    print(f"Model saved as {filename}")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

Экзотика труб.

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

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация изогнутой линии
    t = np.linspace(0, 2*np.pi, 100)
    x = np.cos(t)
    y = np.sin(t)
    z = np.sin(2*t)

    points = np.array([x, y, z]).T

    # Создание трубки
    tube_points = []
    for i, point in enumerate(points):
        if i < len(points) - 1:
            x1, y1, z1 = point
            x2, y2, z2 = points[i+1]
            vec = np.array([x2-x1, y2-y1, z2-z1])
            vec = vec / np.linalg.norm(vec)
            perp_vec1 = np.array([vec[1], -vec[0], 0])
            perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
            perp_vec2 = np.cross(vec, perp_vec1)
            perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
            radius = 0.5
            num_points = 20
            angles = np.linspace(0, 2*np.pi, num_points)
            for k in range(num_points):
                pos = np.array([x1, y1, z1]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
                tube_points.append(pos.tolist())
        else:
            x1, y1, z1 = point
            radius = 0.5
            num_points = 20
            angles = np.linspace(0, 2*np.pi, num_points)
            for k in range(num_points):
                pos = np.array([x1, y1, z1]) + radius * (np.cos(angles[k]) * np.array([1, 0, 0]) + np.sin(angles[k]) * np.array([0, 1, 0]))
                tube_points.append(pos.tolist())

    # Отрисовка трубки
    for i in range(0, len(tube_points), 20):
        for j in range(20):
            if j < 19:
                ax.plot3D(*zip(tube_points[i+j], tube_points[i+j+1]), 'b-')
            else:
                ax.plot3D(*zip(tube_points[i+j], tube_points[i]), 'b-')
        if i < len(tube_points) - 20:
            for j in range(20):
                ax.plot3D(*zip(tube_points[i+j], tube_points[i+20+j]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for i in range(0, len(tube_points), 20):
            for j in range(20):
                if j < 19:
                    f.write(f"f {i+j+1} {i+j+2} {i+20+j+1}\n")
                    f.write(f"f {i+j+2} {i+j+1} {i+20+j+2}\n")
            if i < len(tube_points) - 20:
                for j in range(20):
                    f.write(f"f {i+j+1} {i+j+2} {i+20+j+1}\n")
                    f.write(f"f {i+j+2} {i+j+1} {i+20+j+2}\n")
    print(f"Model saved as {filename}")

    # Отрисовка трубки
    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.set_zlim(-2, 2)
    plt.draw()

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-2, 2)
ax.set_ylim(-2, 2)
ax.set_zlim(-2, 2)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами

[MakarovDs]

Волноломка

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

# Функция для генерации кадра
def update(ax):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for i in range(100):
        t = i / 50.0  # параметр для генерации извилистой линии
        x = np.sin(t) * 50 + 50  # координата x
        y = np.cos(t) * 50 + 50  # координата y
        z = np.random.uniform(-100, 100)  # координата z
        points.append([x, y, z])

    for i in range(len(points) - 1):
        ax.plot([points[i][0], points[i+1][0]], [points[i][1], points[i+1][1]], [points[i][2], points[i+1][2]], 'b-', linewidth=5)

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax)
    plt.pause(0.1)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

Волноломкаятрубаломие

#Это может использоваться как локация к машинариуму какому нибудь.
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import time
import random
import os

# Функция для генерации кадра
def update(ax, i):
    ax.clear()  # Очистка текущего окна

    # Генерация линии
    points = []
    for j in range(100):
        t = j / 50.0  # параметр для генерации извилистой линии
        x = np.sin(t) * 50 + 50  # координата x
        y = np.cos(t) * 50 + 50  # координата y
        z = np.random.uniform(-100, 100)  # координата z
        points.append([x, y, z])

    # Создание трубки
    tube_points = []
    tube_faces = []
    for j in range(len(points) - 1):
        x1, y1, z1 = points[j]
        x2, y2, z2 = points[j+1]
        vec = np.array([x2-x1, y2-y1, z2-z1])
        vec = vec / np.linalg.norm(vec)
        perp_vec1 = np.array([vec[1], -vec[0], 0])
        perp_vec1 = perp_vec1 / np.linalg.norm(perp_vec1)
        perp_vec2 = np.cross(vec, perp_vec1)
        perp_vec2 = perp_vec2 / np.linalg.norm(perp_vec2)
        radius = 5
        num_points = 10
        angles = np.linspace(0, 2*np.pi, num_points)
        for k in range(num_points):
            pos1 = np.array([x1, y1, z1]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            pos2 = np.array([x2, y2, z2]) + radius * (np.cos(angles[k]) * perp_vec1 + np.sin(angles[k]) * perp_vec2)
            tube_points.append(pos1.tolist())
            tube_points.append(pos2.tolist())
            tube_faces.append([len(tube_points)-2, len(tube_points)-1, len(tube_points)])
            tube_faces.append([len(tube_points)-1, len(tube_points)-2, len(tube_points)])

    # Отрисовка трубки
    for j in range(len(tube_points) - 1):
        ax.plot3D(*zip(tube_points[j], tube_points[j+1]), 'b-')

    # Сохранение трубки в файл OBJ
    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
    filename = os.path.join(desktop_path, f"wave_tube_{i+1}.obj")
    with open(filename, "w") as f:
        for j, point in enumerate(tube_points):
            f.write(f"v {point[0]} {point[1]} {point[2]}\n")
        for face in tube_faces:
            f.write(f"f {face[0]+1} {face[1]+1} {face[2]+1}\n")
    print(f"Model saved as {filename}")

# Запуск анимации
plt.ion()  # Включение интерактивного режима
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-150, 150)
ax.set_ylim(-150, 150)
ax.set_zlim(-150, 150)

for i in range(100):
    update(ax, i)
    plt.pause(5)  # Пауза между кадрами
    plt.draw()  # Отрисовка текущего кадра

plt.ioff()  # Выключение интерактивного режима
plt.show()  # Окончательный кадр

[MakarovDs]

Дисперсное облако пыли.

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

def generate_space():
    x, y, z = np.random.uniform(-10, 10), np.random.uniform(-10, 10), np.random.uniform(-10, 10)
    depth = np.random.randint(1, 10)
    points = [np.array([x, y, z])]
    for i in range(depth):
        x1 = x + np.random.uniform(-1, 1)
        y1 = y + np.random.uniform(-1, 1)
        z1 = z + np.random.uniform(-1, 1)
        points.append(np.array([x1, y1, z1]))
    return points

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 save_fractal(verts, faces, filename):
    try:
        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))
        print(f"Model saved as {filename}")
    except Exception as e:
        print(f"Error saving model: {e}")

# Начальные параметры
points = []
for i in range(100):
    points.extend(generate_space())

# Масштабируем точки так, чтобы они вмещались в массив
points = np.array(points)
min_vals = np.min(points, axis=0)
max_vals = np.max(points, axis=0)
scale_factors = np.array((128, 128, 128)) / (max_vals - min_vals)
scaled_points = (points - min_vals) * scale_factors
scaled_points = np.clip(scaled_points, 0, np.array((128, 128, 128)) - 1)

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

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

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

# Визуализация модели
verts = verts * np.array((128, 128, 128)) / np.max(np.array((128, 128, 128)))  # Масштабируем обратно для визуализации
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, 1], [0, 1], [0, 1])  # Устанавливаем диапазоны для осей

# Показываем окно с моделью
plt.show()

# Сохранение фрактала в формате OBJ
output_path = os.path.join(os.path.expanduser('~'), 'Desktop', 'fractal.obj')
save_fractal(verts, faces, output_path)