Python для 3D графики и VR: создание виртуальных миров

import OpenGL.GL as gl
import OpenGL.GLUT as glut

def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glBegin(gl.GL_TRIANGLES)
gl.glVertex3f(-0.5, -0.5, 0)
gl.glVertex3f(0.5, -0.5, 0)
gl.glVertex3f(0, 0.5, 0)
gl.glEnd()
glut.glutSwapBuffers()

glut.glutInit()
glut.glutCreateWindow("Simple Triangle")
glut.glutDisplayFunc(display)
glut.glutMainLoop()

from panda3d.core import *
from direct.showbase.ShowBase import ShowBase

class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Загрузка 3D-модели
self.model = self.loader.loadModel("models/teapot")
self.model.reparentTo(self.render)
# Позиционирование модели
self.model.setPos(0, 10, 0)

app = MyApp()
app.run()

from vpython import *

# Создание простой 3D-сцены с планетами
sun = sphere(pos=vector(0,0,0), radius=1, color=color.yellow)
earth = sphere(pos=vector(3,0,0), radius=0.3, color=color.blue,
make_trail=True, trail_color=color.white)
earth.velocity = vector(0, 0.5, 0)

dt = 0.01
while True:
rate(100)
r = earth.pos – sun.pos
earth.velocity -= 0.01 * norm(r) * dt
earth.pos += earth.velocity * dt

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

# Создание 3D-графика
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

# Генерация данных
theta = np.linspace(0, 2*np.pi, 100)
z = np.linspace(0, 2, 100)
r = z**2
x = r * np.sin(theta)
y = r * np.cos(theta)

# Построение спирали
ax.plot(x, y, z, label='Параметрическая кривая')
ax.legend()
plt.show()

import openvr
import numpy as np

# Инициализация OpenVR
vr_system = openvr.init(openvr.VRApplication_Scene)

# Получение позиции контроллера
def get_controller_position():
result, pose = vr_system.getControllerState(0)
if result == 0:
pose_mat = np.array(pose.mDeviceToAbsoluteTracking.m)
# Преобразование матрицы 3x4 в позицию
position = pose_mat[:3, 3]
return position
return None

# Основной цикл
while True:
position = get_controller_position()
if position is not None:
print(f"Controller position: {position}")

import pybullet as p
import pybullet_data
import time

# Подключение к физическому серверу в режиме VR
physicsClient = p.connect(p.GUI)
p.setAdditionalSearchPath(pybullet_data.getDataPath())
p.setGravity(0, 0, -9.81)

# Загрузка плоскости и объекта
planeId = p.loadURDF("plane.urdf")
boxId = p.loadURDF("cube.urdf", [0, 0, 1])

# Включение VR-режима
p.configureDebugVisualizer(p.COV_ENABLE_VR_RENDER_CONTROLLERS, 1)
p.configureDebugVisualizer(p.COV_ENABLE_VR_PICKING, 1)
p.configureDebugVisualizer(p.COV_ENABLE_VR_TELEPORTING, 1)

# Симуляция
while p.isConnected():
p.stepSimulation()
time.sleep(1/240.)

from aframe import * # A-Frame для WebVR через Python
from browser import document, window

# Создание VR-сцены
scene = Scene(embedded=True)
scene.append(Box(position="-1 0.5 -3", rotation="0 45 0", color="#4CC3D9"))
scene.append(Sphere(position="0 1.25 -5", radius="1.25", color="#EF2D5E"))
scene.append(Cylinder(position="1 0.75 -3", radius="0.5", height="1.5", color="#FFC65D"))
scene.append(Plane(position="0 0 -4", rotation="-90 0 0", width="4", height="4", color="#7BC8A4"))
scene.append(Sky(color="#ECECEC"))

# Добавление VR-контроллеров
scene.append(Entity('a-entity', position="0 1.6 0", camera=True, 'look-controls'=""))
scene.append(Entity('a-entity', 'laser-controls'="hand: left"))
scene.append(Entity('a-entity', 'laser-controls'="hand: right"))

# Отображение сцены
document.body.append(scene.element)

import bge

cont = bge.logic.getCurrentController()
own = cont.owner

# Добавление физического движения объекту
if bge.logic.keyboard.events[bge.events.WKEY] == bge.logic.KX_INPUT_ACTIVE:
own.applyMovement([0, 0.1, 0], True)

# Интеграция с VR через OSVR или OpenVR
if hasattr(bge, "vr"):
hmd = bge.vr.headsets[0]
# Получение позиции и ротации HMD
position = hmd.position
rotation = hmd.rotation
# Применение их к камере
own.worldPosition = position
own.worldOrientation = rotation.to_matrix()

# В GDScript
extends Spatial

var python_script

func _ready():
# Загрузка и инициализация Python-модуля
python_script = load("res://python_module.py").new()
# Вызов метода Python из GDScript
var result = python_script.process_data({"position": Vector3(1, 2, 3)})
print("Result from Python: ", result)

# python_module.py
import godot
from godot import exposed, export, Vector3

@exposed
class PythonScript(godot.Node):

def process_data(self, data):
# Обработка данных из Godot
position = data["position"]
# Выполнение сложных вычислений, например, с NumPy
import numpy as np
# Симуляция обработки данных
result = np.array([position.x, position.y, position.z]) * 2
return {"processed_position": Vector3(result[0], result[1], result[2])}

# Пример Python-скрипта для Unreal Engine
import unreal

# Создание нового уровня
level = unreal.EditorLevelLibrary.new_level("/Game/Levels/PythonCreatedLevel")

# Добавление объектов
cube = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.StaticMeshActor,
unreal.Vector(0, 0, 100),
unreal.Rotator(0, 0, 0)
)

# Настройка свойств объекта
cube.static_mesh_component.set_static_mesh(
unreal.EditorAssetLibrary.load_asset("/Engine/BasicShapes/Cube")
)

# Интеграция с VR
vr_pawn = unreal.EditorLevelLibrary.spawn_actor_from_class(
unreal.VRPawn, # Предполагаемый класс VR-пешки
unreal.Vector(0, 0, 0),
unreal.Rotator(0, 0, 0)
)

# Сохранение результатов
unreal.EditorLevelLibrary.save_current_level()

// C# скрипт в Unity, использующий Python.NET
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Python.Runtime;

public class PythonIntegration : MonoBehaviour
{
void Start()
{
// Инициализация Python
PythonEngine.Initialize();
using (Py.GIL())
{
// Выполнение Python-кода
PythonEngine.RunSimpleString(@"
import numpy as np

def calculate_trajectory(velocity, angle, gravity=9.8):
velocity_x = velocity * np.cos(np.radians(angle))
velocity_y = velocity * np.sin(np.radians(angle))
time_of_flight = 2 * velocity_y / gravity
max_height = velocity_y**2 / (2 * gravity)
range_distance = velocity_x * time_of_flight
return range_distance, max_height
");

// Получение результатов из Python
dynamic scope = Py.Import("__main__");
var result = scope.calculate_trajectory(20, 45);
Debug.Log($"Range: {result[0]}, Max Height: {result[1]}");
}
}
}

import numpy as np
import pyvista as pv

# Создание структурированной сетки
x = np.arange(-10, 10, 0.25)
y = np.arange(-10, 10, 0.25)
x, y = np.meshgrid(x, y)
r = np.sqrt(x**2 + y**2)
z = np.sin(r)

# Создание поверхности и визуализация
grid = pv.StructuredGrid(x, y, z)
grid.plot(
show_edges=True,
color="white",
line_width=0.1,
show_scalar_bar=True,
screenshot="surface_plot.png"
)

# Добавление интерактивности для VR
plotter = pv.Plotter()
plotter.add_mesh(grid, show_edges=True, color="white", line_width=0.1)
plotter.enable_eye_dome_lighting()
plotter.show(title="Интерактивная визуализация синусоидальной волны")

from direct.showbase.ShowBase import ShowBase
from panda3d.core import *
import math

class SolarSystemVR(ShowBase):
def __init__(self):
ShowBase.__init__(self)

# Настройка VR (требуется плагин для Panda3D)
self.vr_manager = self.loader.loadModel("models/vr_manager")
self.vr_manager.reparentTo(self.render)

# Создание солнца
self.sun = self.loader.loadModel("models/sphere")
self.sun.setScale(2)
self.sun.setPos(0, 0, 0)
self.sun.setColor(1, 0.9, 0, 1)
self.sun.reparentTo(self.render)

# Создание планет
self.planets = []
planet_data = [
{"name": "Mercury", "distance": 4, "size": 0.4, "color": (0.8, 0.8, 0.8, 1), "speed": 4.1},
{"name": "Venus", "distance": 7, "size": 0.9, "color": (0.9, 0.7, 0.4, 1), "speed": 1.6},
{"name": "Earth", "distance": 10, "size": 1, "color": (0.2, 0.3, 0.8, 1), "speed": 1},
# Другие планеты
]

for data in planet_data:
planet = self.loader.loadModel("models/sphere")
planet.setScale(data["size"])
planet.setPos(data["distance"], 0, 0)
planet.setColor(*data["color"])
planet.reparentTo(self.render)
self.planets.append({"model": planet, "data": data, "angle": 0})

# Добавление вращения
self.taskMgr.add(self.update_planets, "UpdatePlanets")

# Добавление информационных панелей
self.setup_info_panels()

def update_planets(self, task):
dt = globalClock.getDt()
for planet in self.planets:
# Обновление положения планеты
planet["angle"] += dt * planet["data"]["speed"] * 0.1
x = math.cos(planet["angle"]) * planet["data"]["distance"]
y = math.sin(planet["angle"]) * planet["data"]["distance"]
planet["model"].setPos(x, y, 0)
return task.cont

def setup_info_panels(self):
# Добавление интерактивных информационных панелей
# Код для создания текстовых панелей с данными о планетах
pass

app = SolarSystemVR()
app.run()

import simpy
import numpy as np
import pyvista as pv

# Создание среды симуляции производственной линии
env = simpy.Environment()

# Параметры модели
processing_times = {"station1": np.random.normal(10, 2, 1000),
"station2": np.random.normal(15, 3, 1000),
"station3": np.random.normal(12, 2, 1000)}

# Функция для симуляции процесса
def part_process(env, name, stations):
current_time = env.now
print(f"{name} начал обработку в {current_time:.2f}")

for station in stations:
process_time = processing_times[station][np.random.randint(0, 1000)]
yield env.timeout(process_time)
current_time = env.now
print(f"{name} завершил обработку на {station} в {current_time:.2f}")

# Сбор данных для визуализации
completion_times.append(current_time)

# Запуск симуляции
completion_times = []
for i in range(50):
env.process(part_process(env, f"Деталь {i}", ["station1", "station2", "station3"]))

env.run(until=500)

# Визуализировать результаты в 3D
plotter = pv.Plotter()
# Создание 3D-модели производственной линии
# ... (код для создания геометрии на основе данных симуляции)
plotter.show()

# Визуализация статистики в виде 3D-гистограммы
histogram = np.histogram(completion_times, bins=20)
x, y = np.meshgrid(range(len(histogram[0])), range(1))
z = np.array([histogram[0]])

# Создание 3D-гистограммы
grid = pv.StructuredGrid(x, y, z)
plotter = pv.Plotter()
plotter.add_mesh(grid, show_edges=True, opacity=0.7, color="blue")
plotter.show()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import seaborn as sns

# Загрузка данных о движениях пользователя в VR (предполагаемый формат CSV)
data = pd.read_csv("vr_movement_data.csv")

# Анализ данных о движениях
x = data["position_x"]
y = data["position_y"]
z = data["position_z"]

# Создание 3D-визуализации траектории движения
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
ax.plot(x, y, z, label='Траектория движения в VR')
ax.set_xlabel('X позиция')
ax.set_ylabel('Y позиция')
ax.set_zlabel('Z позиция')
ax.legend()
plt.savefig("vr_trajectory_3d.png")

# Создание тепловой карты интенсивности взаимодействия
heatmap_data = np.histogram2d(x, z, bins=50)[0]
plt.figure(figsize=(12, 10))
sns.heatmap(heatmap_data, cmap="hot")
plt.title("Тепловая карта взаимодействия пользователя в VR")
plt.xlabel("X позиция (бин)")
plt.ylabel("Z позиция (бин)")
plt.savefig("vr_interaction_heatmap.png")

# Анализ времени, проведенного в различных зонах VR-пространства
zone_data = pd.cut(y, bins=5, labels=["Зона 1", "Зона 2", "Зона 3", "Зона 4", "Зона 5"])
zone_times = data.groupby(zone_data)["time_spent"].sum()

plt.figure(figsize=(10, 6))
zone_times.plot(kind="bar")
plt.title("Время, проведенное в различных зонах VR-пространства")
plt.xlabel("Зона")
plt.ylabel("Время (секунды)")
plt.tight_layout()
plt.savefig("vr_zone_time_analysis.png")