def toxy(v):
return Vector3(v.x, v.y, 0)
def drawwideline(p0, p1, w, color):
f = (p0 - p1).cross(Vector3(0, 0, 1))
f = f.normalize() if f.length() else Vector3(1, 0, 0)
for d in (-w, 0, w):
drawline(p0 + d * f, p1 + d * f, color)
def pickvector(self): self.uspin = Vector3(random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1)) self.uspin = self.uspin.normalize() if self.uspin.length() else Vector3(0, 0, 1)
def extractjoiner(jjoiner, joiner):
jp0 = joiner["jp0"]
jp1 = joiner["jp1"]
p0 = pools[jp0]["pos"]
p1 = pools[jp1]["pos"]
w = joiner["w"]
waypoints = list(joiner["waypoints"])
jcurves = [True] + [r > 0 for p, r in waypoints] + [True]
p0s = [p0] + [p for p, r in waypoints] + [p1]
ps = [p0]
curvedata = []
iscurve = [False]
for k, (p, r) in enumerate(waypoints):
if r == 0:
ps.append(p)
iscurve.append(False)
else:
k0, k1, k2 = k, k + 1, k + 2
while not jcurves[k0]:
k0 -= 1
while not jcurves[k2]:
k2 += 1
pA, pB, pC = Vector3(p0s[k0]), Vector3(p0s[k1]), Vector3(p0s[k2])
f0 = pB - pA
f1 = pC - pB
f0.z = 0
f1.z = 0
if f0.length() == 0 or f1.length == 0:
print("Error dumping joiner %d: %s, %d, %s" %
(jjoiner, joiner, k, p))
return
f0 = f0.normalize()
f1 = f1.normalize()
if abs(f0.dot(f1)) > 0.999:
print("Error dumping joiner %d: %s, %d, %s" %
(jjoiner, joiner, k, p))
return
f = (f1 - f0).normalize()
z = f1.cross(f0).normalize()
beta = 1 / 2 * math.acos(f0.dot(f1))
center = pB + f * r / math.cos(beta)
ps.append(center - r * f.rotate(math.degrees(beta), z))
ps.append(center - r * f.rotate(math.degrees(-beta), z))
curvedata.append((center, beta, z.z > 0, r))
iscurve.append(True)
iscurve.append(False)
ps.append(p1)
cons = [("pool", jp0)] + [(jjoiner, k)
for k in range(len(ps) - 1)] + [("pool", jp1)]
k = 0
while len(ps) > 2:
if ps[0][2] != ps[1][2]:
yield totuple("slope", jjoiner, k, *cons[k], *cons[k + 2], *ps[0],
*ps[1], w)
elif iscurve[k]:
center, beta, right, r = curvedata[0]
del curvedata[0]
yield totuple("curve", jjoiner, k, *cons[k], *cons[k + 2], *ps[0],
*ps[1], w, *center, beta, right, r)
k += 1
del ps[0]
yield totuple("straight", jjoiner, k, *cons[k], *cons[k + 2],
*ps[0], *ps[1], w)
else:
yield totuple("straight", jjoiner, k, *cons[k], *cons[k + 2],
*ps[0], *ps[1], w)
del ps[0]
k += 1
# del waypoints[0]
if len(ps) > 1:
yield totuple("straight", jjoiner, k, *cons[k], *cons[k + 2], *ps[0],
*ps[1], w)
def generate(self):
self.shader = ShaderProgram("./shaders/vs.glsl", "./shaders/fs.glsl")
self.shader.addUniform("screen_dim")
self.shader.addUniform("mat_transform")
self.shader.addUniform("mat_projection")
self.shader.addUniform("mat_view")
self.cubeShader = ShaderProgram("./shaders/cube_vs.glsl",
"./shaders/cube_fs.glsl")
self.cubeShader.addUniform("mat_transform")
self.cubeShader.addUniform("mat_projection")
self.cubeShader.addUniform("mat_view")
self.lightShader = ShaderProgram("./shaders/light_vs.glsl",
"./shaders/light_fs.glsl")
self.lightShader.addUniform("mat_transform")
self.lightShader.addUniform("mat_projection")
self.lightShader.addUniform("mat_view")
# ** every shader must be added list of shader called shaders
self.shaders = [self.shader, self.cubeShader, self.lightShader]
self.meshes = []
self.renderer = Renderer(self.shaders)
self.pos = glm.vec2(0, 0)
self.angle = 0
self.transform = glm.identity(glm.mat3x3)
self.model = Mesh((-1.0, -0.0), (.3, .3), "./res/image.png")
self.cube_model = Cube()
self.light_model = Light()
# self.light_model = Light(0.5)
self.e = Entity(self.model, Vector3(0, 0, 0), Vector3(0.0, 0.0, 0.0),
Vector3(1, 1, 1))
self.cube_entity = Entity(self.cube_model, Vector3(-1, -1, -1),
Vector3(0.0, 0.0, 0.0), Vector3(1, 1, 1))
self.light_entity = Entity(self.light_model, Vector3(-0.5, -0.5, -0.5),
Vector3(0.0, 0.0, 0.0),
Vector3(0.2, 0.2, 0.2))
self.shadersDict = {
self.e: [self.shader, False],
self.cube_entity: [self.cubeShader, True],
self.light_entity: [self.lightShader, True]
}
precision = 3
self.cube_entities = []
r = 3
for i in range(10):
x = round(uniform(-r, r), precision)
y = round(uniform(-r, r), precision)
z = round(uniform(-r, r), precision)
self.cube_entities.append(
Entity(self.cube_model, Vector3(x, y, z),
Vector3(0.0, 0.0, 0.0), Vector3(0.5, 0.5, 0.5)))
self.shadersDict[self.cube_entities[i]] = [self.cubeShader, True]
# self.cube_entities = Entity(self.cube_model, Vector3(0,0,0), Vector3(0.0,0.0,0.0), Vector3(1,1,1))
self.camera = Camera()
def main():
"Executando o algoritmo"
# --- BOIDS CONSTANTS --- #
global f_cohesion, f_alignment, f_separation
num_boids = 200
f_cohesion = 0.0006
f_alignment = 0.03
f_separation = 0.01
# Inicializando o pygame e configurando a exibição do OpenGL
angle = 0.1 # ângulo de rotação da câmera
## side = 700
side = 650 # tamanho da janela
delay = 0 # time to delay each rotation, in ms
xyratio = 1.0 # == xside / yside
title = 'Python Boids'
# random.seed(42) # for repeatability
# --- INICIALIZANDO TKINTER --- #
master = Tk()
w = 300
h = 150
ws = master.winfo_screenwidth() # width of the screen
hs = master.winfo_screenheight() # height of the screen
x = (ws / 2) - (w / 2) + 200
y = (hs / 2) - (h / 2)
master.geometry('%dx%d+%d+%d' % (w, h, x, y))
master.protocol("WM_DELETE_WINDOW", quit_callback)
master = Frame(master)
master.pack()
fontePadrao = ("Arial", "10")
primeiroContainer = Frame(master)
primeiroContainer["pady"] = 10
primeiroContainer.pack()
segundoContainer = Frame(master)
segundoContainer["pady"] = 5
segundoContainer["padx"] = 20
segundoContainer.pack()
terceiroContainer = Frame(master)
terceiroContainer["pady"] = 5
terceiroContainer["padx"] = 20
terceiroContainer.pack()
quartoContainer = Frame(master)
quartoContainer["pady"] = 5
quartoContainer["padx"] = 20
quartoContainer.pack()
titulo = Label(primeiroContainer, text="Boids Constants")
titulo["font"] = ("Arial", "10", "bold")
titulo.pack()
nomeLabel = Label(segundoContainer,
text="(1-2) Cohesion: ",
font=fontePadrao)
nomeLabel.pack(side=LEFT)
cohesion_entry = Entry(segundoContainer, justify=CENTER)
cohesion_entry["font"] = fontePadrao
cohesion_entry.insert(0, str(f_cohesion))
cohesion_entry.pack(side=LEFT)
nomeLabel = Label(terceiroContainer,
text="(3-4) Alignment: ",
font=fontePadrao)
nomeLabel.pack(side=LEFT)
alignment_entry = Entry(terceiroContainer, justify=CENTER)
alignment_entry["font"] = fontePadrao
alignment_entry.insert(0, str(f_alignment))
alignment_entry.pack(side=LEFT)
nomeLabel = Label(quartoContainer,
text="(5-6) Separation: ",
font=fontePadrao)
nomeLabel.pack(side=LEFT)
separation_entry = Entry(quartoContainer, justify=CENTER)
separation_entry["font"] = fontePadrao
separation_entry.insert(0, str(f_separation))
separation_entry.pack(side=LEFT)
# Inicializando o pygame
pygame.init()
pygame.display.set_caption(title, title)
pygame.display.set_mode((side, side), pyg.OPENGL | pyg.DOUBLEBUF)
# Inicializando o OpenGL no pygame
gl.glEnable(gl.GL_DEPTH_TEST) # use our zbuffer
gl.glClearColor(0, 0, 0, 0)
# Configurando o espaço tridimensional
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
# glu.gluPerspective(60.0, xyratio, 1.0, 250.0) # setup lens
## edge = 40.0
edge = 50.0 # aresta do cubo
glu.gluPerspective(60.0, xyratio, 1.0, (6 * edge) + 10) # setup lens
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
# glu.gluLookAt(0.0, 0.0, 150, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
glu.gluLookAt(0.0, 0.0, 3 * edge, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
gl.glPointSize(3.0)
cube0 = Vector3(-edge, -edge, -edge) # cube min vertex
cube1 = Vector3(+edge, +edge, +edge) # cube max vertex
# --- Inicializando os boids e o cubo --- #
theflock = flock(num_boids, cube0, cube1)
while True:
event = pygame.event.poll()
if event.type == pyg.QUIT or (event.type == pyg.KEYDOWN and
(event.key == pyg.K_ESCAPE
or event.key == pyg.K_q)):
break
if (event.type == pygame.KEYDOWN):
# ALTERANDO COESÃO
if (event.key == pygame.K_1):
f_cohesion -= 0.0001
cohesion_entry.delete(0, END)
cohesion_entry.insert(0, str(round(f_cohesion, 6)))
if (event.key == pygame.K_2):
f_cohesion += 0.0001
cohesion_entry.delete(0, END)
cohesion_entry.insert(0, str(round(f_cohesion, 6)))
# ALTERANDO ALINHAMENTO
if (event.key == pygame.K_3):
f_alignment -= 0.01
alignment_entry.delete(0, END)
alignment_entry.insert(0, str(round(f_alignment, 6)))
if (event.key == pygame.K_4):
f_alignment += 0.01
alignment_entry.delete(0, END)
alignment_entry.insert(0, str(round(f_alignment, 6)))
# ALTERANDO SEPARAÇÃO
if (event.key == pygame.K_5):
f_separation -= 0.01
separation_entry.delete(0, END)
separation_entry.insert(0, str(round(f_separation, 6)))
if (event.key == pygame.K_6):
f_separation += 0.01
separation_entry.delete(0, END)
separation_entry.insert(0, str(round(f_separation, 6)))
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Renderizando o cubo e os boids
theflock.render()
gl.glRotatef(angle, 0, 1, 0) # rotacionando a tela no eixo y
pygame.display.flip()
if delay > 0:
pygame.time.wait(delay)
# Atualizando a posição dos boids
theflock.update()
try:
master.update()
except:
print("dialog error")
master.destroy()
def __init__(self, position, direction):
self.pos = Vector3(position)
self.rot = Vector3(direction).normalize()
def __init__(self):
self.vitesse = 1000
self.taille = 6
self.position = Vector2()
self.direction = Vector2()
self.couleur = Vector3()
def __init__(self, position, direction, color=(0, 0, 0)):
super().__init__(position, direction)
self.color = Vector3(color)
self.radius = 0
def global_light_color(self, ray, distance, source):
return [
int(i / 2 + .5) for i in (
Vector3(self.color) *
max((-self.ray_normal(ray, distance) * source + 1), 0.25))
]
# Vector con todos los posibles valores de un puente, el primer valor será el de por defecto
puente = [0] + puente_horizontal + puente_vertical
# Número de pixeles que ocupará el texto
TAMA_TEXTO = 30
# Número de pixeles que tendrá cada puente
TAMA_PUENTE = TAMA_TEXTO * 3
# Colores de las superficies
FONDO = (240, 240, 240) # color del fondo
NODOS = (255, 255, 255) # color para el centro de un nodo
NUMEROS = (0, 0, 0
) # color para los valores de los nodos y el borde de los nodos
PUENTES = (0, 0, 0) # color de los puentes
PUENTES_FONDO = Vector3(PUENTES).lerp(
Vector3(FONDO), 0.7) # color especial para puentes por defecto
MARCADO = (255, 0, 0) # color del borde en los nodos marcados
VISITADO = (255, 128, 0)
COMPLETADO = (0, 128, 0)
ESPACIO = 5 # espacio entre los nodos y el borde exterior
def dibujar_texto(surface,
texto,
pos,
color=(0, 0, 0),
fuente='Comic Sans MS'):
'''
Mostrar texto en pantalla
:param surface: superficie sobre la que se dibujará
def project(self, vector, win_width, win_height, fov, viewer_distance):
factor = fov / (viewer_distance + vector.z)
x = vector.x * factor + win_width / 2
y = -vector.y * factor + win_height / 2
return Vector3(x, y, vector.z)
points[face[3]].z) / 4.0
avg_z.append([i, z])
return avg_z
def create_polygon(self, face, transformed_vectors):
return [(int(transformed_vectors[f].x), int(transformed_vectors[f].y))
for f in face]
pygame.init()
screen = pygame.display.set_mode((400, 600))
cube = Cube([
Vector3(-1, 1, -1),
Vector3(1, 1, -1),
Vector3(1, -1, -1),
Vector3(-1, -1, -1),
Vector3(-1, 1, 1),
Vector3(1, 1, 1),
Vector3(1, -1, 1),
Vector3(-1, -1, 1)
], screen.get_width(), screen.get_height())
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
import random
import pygame
import time
import numpy as np
from pygame.math import Vector2, Vector3
from find_hand import FindHand
hand = FindHand()
pygame.init()
FONT = pygame.font.SysFont('Helvetica', 25)
FPS = 30
WIN_WIDTH = 1538
WIN_HEIGHT = 834
WIN_DEPTH = int(WIN_WIDTH * 1.5)
WIN_CENTER = Vector3(WIN_WIDTH // 2, WIN_HEIGHT // 2, WIN_DEPTH // 2)
DEPTH_RATIO = 1 / 4
BACK_WIN_WIDTH = int(WIN_WIDTH * DEPTH_RATIO)
BACK_WIN_HEIGHT = int(WIN_HEIGHT * DEPTH_RATIO)
MAX_SCORE = 3
DISPLAY = (WIN_WIDTH, WIN_HEIGHT)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (160, 160, 160)
RED = (255, 0, 0)
GREEN = (0, 200, 0)
# Points connecting lines in background
POINT_1 = [0, 0]
POINT_2 = [WIN_WIDTH, 0]
POINT_3 = [0, WIN_HEIGHT]
if the_args[0].upper() == 'SCENE':
print("scene mode")
scene_f = the_args[1]
sr = scene_reader.SceneReader(scene_f, WINDOW_MODE)
sys.exit(0)
# this is dead code
assert 1 == 0
sinw = lambda: sin_wave_generator(mul=60, speed=1, baseline=0.5)
halfer = lambda x: list(a / 2 for a in x)
gene = lambda x: default_number_generator(x)
v2tov3 = lambda x: Vector3(x[0], x[1], 0)
GRAY = (30, 30, 30)
SCREEN_SIZE = (1200, 900)
TRIANGLE_SIZE = (700, int(700 / 1.622))
TRIANGLE_SIZE_2 = (400, 400)
GRID_SIZE = (150, 200)
SQUARE_SIZE = (200, 200)
# positions
TOP_LEFT = (0, 0)
TOP_RIGHT = (SCREEN_SIZE[0], 0)
TOP_MIDDLE = (SCREEN_SIZE[0] / 2, 0)
MIDDLE_LEFT = (0, SCREEN_SIZE[1] / 2)
MIDDLE_RIGHT = (SCREEN_SIZE[0] / 2, SCREEN_SIZE[1] / 2)
MIDDLE_MIDDLE = (SCREEN_SIZE[0] / 2, SCREEN_SIZE[1] / 2)
def think(dt, dmx, dmy): self.tosnap = max(self.tosnap - dt, 0) if settings.manualcamera: self.mgamma = math.clamp(self.mgamma - 100 * dmy, 5, 85) self.mphi -= 100 * dmx camera = 1 * state.you.pos atilt = state.you.section.atilt(state.you) Rvantage = 20 gamma = 55 - state.you.drainangle() phi = -math.degrees(state.you.heading) if state.you.section.fmode is None: pass elif state.you.section.fmode: if not self.fmode: self.fmode = True self.tosnap = 1 else: if self.fmode: self.fmode = False self.tosnap = 1 if state.you.section.bmode is None: pass elif state.you.section.bmode: if not self.bmode: self.bmode = True self.tosnap = 1 else: if self.bmode: self.bmode = False self.tosnap = 0.5 if self.fmode: # if state.you.section.label == "pool": self.fcamera = state.you.section.pos * 1 camera = math.softapproach(self.camera, self.fcamera, 2 * dt) phi = 0 gamma = 40 Rvantage = math.softapproach(self.Rvantage, 28, 3 * dt) if self.bmode: camera = math.softapproach(self.camera, state.you.section.pos, 1 * dt) d = state.you.pos - state.you.section.pos d.z = 0 if d.x == 0 and d.y == 0: kappa = 0 else: kappa = math.degrees(math.atan2(d.y, d.x)) - 90 dphi = math.zmod(self.bphi - kappa, 360) if 0 < dphi < 70: self.bphi += 70 - dphi elif -70 < dphi < 0: self.bphi += -70 - dphi phi = self.bphi gamma = 55 Rvantage = math.softapproach(self.Rvantage, 45, 3 * dt) if state.you.section.rapid > 1: if not self.rapid: self.tosnap = 1 self.rapid = True Rvantage = 12 gamma = 68 else: if self.rapid: self.tosnap = 1 self.rapid = False # f is approximately dt / self.tosnap for large values of self.tosnap # rapidly approaches 1 as self.tosnap goes to 0 fsnap = 1 - math.exp(-dt / self.tosnap) if self.tosnap > 0 else 1 if settings.manualcamera: gamma = self.mgamma phi = self.mphi self.gamma = math.mix(self.gamma, gamma, fsnap) self.phi += fsnap * math.zmod(phi - self.phi, 360) if fsnap == 0: self.phi = phi self.Rvantage = math.mix(self.Rvantage, Rvantage, fsnap) self.atilt = math.mix(self.atilt, atilt, 2 * dt) if not settings.manualcamera: self.mgamma = self.gamma self.mphi = self.phi theta = self.gamma uvantage = Vector3(0, 0, 1).rotate_x(theta).rotate_z(self.phi) dtilt = self.atilt.length() utilt = self.atilt.normalize() if dtilt else Vector3(0, 0, 1) self.camera = camera self.vantage = self.camera + self.Rvantage * uvantage.rotate(dtilt, utilt) self.up = Vector3(0, 0, 1).rotate_z(self.phi).rotate(dtilt, utilt)
def researcher():
step = +0.0001
start = 0
while True:
yield Vector3(math.pi / 6, 0, 0)
start -= step
self.img,
(self.pos[0] - self.img.get_width() / 2,
self.pos[1] - self.img.get_height() - self.pos[2]),
)
levels = []
for i in range(1, 6):
levels.append(pygame.image.load("level%i.png" % i).convert())
nlevel = 0
level = levels[0]
red = Bubble("red.png", "smile")
blue = Bubble("blue.png", "frown")
red.pos = Vector3(100, HEIGHT / 2, 0)
blue.pos = Vector3(WIDTH - 100, HEIGHT / 2, 0)
red.vel = Vector3(0, 0, 0)
blue.vel = Vector3(0, 0, 0)
bubbles = [red, blue]
pills = []
font = pygame.font.Font("Apercu-Bold.otf", 40)
#font = pygame.font.SysFont("monospace", 20)
pygame.joystick.init()
joysticks = [
pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())
]
def atilt(self, you):
return Vector3(0, 0, 0)
def random_Vector3(lower=0.0, upper=1.0):
"return a Vector3 with random elements between lower and upper"
return Vector3(random_range(lower, upper), random_range(lower, upper),
random_range(lower, upper))
PS this entire program is a nightmare.
"""
from __future__ import division
import sys, pygame, math, json, os, sys, random
from pygame.locals import *
from pygame.math import Vector2, Vector3
from . import ptext
fname = sys.argv[1]
savefile = "/tmp/%s.json" % fname
dumpfile = "/tmp/%s.csv" % fname
zoom = 1
p0 = Vector3(0, 0, 0)
# ISO convention https://en.wikipedia.org/wiki/Spherical_coordinate_system
theta = 1
phi = 0
screenw, screenh = 1024, 720
screen = pygame.display.set_mode((screenw, screenh))
# previous value within sorted list vs less than v
def pvalue(vs, v, wrap=True):
xs = [x for x in vs if x < v]
return xs[-1] if xs else vs[-1 if wrap else 0]
def __init__(self):
"initialize the correction base class"
self.delta = Vector3(0.0, 0.0, 0.0) # velocity correction
self.num = 0 # number of participants
self.neighborhood = 5.0 # area for this correction
def __init__(self):
self.size = 10
self.couleur = Vector3()
self.direction = Vector2()
self.position = Vector2()
