def main():
""" create window, add shaders & scene objects, then run rendering loop """
width = 640
height = 480
camera = Camera(vec(0, 0, -5), 60, height / width, .3, 1000)
scene = Scene(camera,
light=vec(-.57735026919, -.57735026919, .57735026919) * .5)
pyramidMesh = Mesh(vertices=np.array(
((0, .5, 0), (.5, -.5, 0), (-.5, -.5, 0)), 'f'),
normals=np.array(
((0, 0, -1), (0.70710678118, 0, -0.70710678118),
(-0.70710678118, 0, -0.70710678118)), 'f'),
perVertexColor=np.array(
((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
'f'),
indexes=np.array((0, 1, 2), 'u4'))
suzanne = Mesh.LoadMeshes("models/suzanne.obj")[0]
scene.Add3DObject(
Object3D(0,
translate(-1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), -200),
suzanne, Material("shaders/rainbow_shaded.frag")))
scene.Add3DObject(
Object3D(1,
translate(1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), 200),
suzanne, Material("shaders/shaded.frag")))
renderer = Renderer(scene)
renderer.Run()
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# place instances of our basic objects
#
phi, theta, psi = 30, 20, 40
# # construct our robot arm hierarchy for drawing in viewer
cylinder = Cylinder(40) # re-use same cylinder instance
limb_shape = Node(transform=scale(1 / 4, 1 / 4, 5)) # make a thin cylinder
limb_shape.add(cylinder) # common shape of arm and forearm
rotate2 = RotationControlNode(glfw.KEY_E, glfw.KEY_D, (1, 0, 0))
rotate2.add(limb_shape)
forearm_node = Node(transform=translate(0, 0, 5 - 1 / 4) @ rotate(
(1, 0, 0), psi)) # robot arm rotation with phi angle
forearm_node.add(rotate2)
arm_node = Node(transform=translate(0, 0, 0.5) @ rotate(
(1, 0, 0), phi)) # robot arm rotation with phi angle
arm_node.add(limb_shape, forearm_node)
rotate1 = RotationControlNode(glfw.KEY_F, glfw.KEY_S, (1, 0, 0))
rotate1.add(arm_node)
# make a flat cylinder
base_shape = Node(transform=identity(), children=[cylinder])
# viewer.add(base_node)
viewer.add(TexturedPlane("control/arrows.png"))
# viewer.add(Cylinder(200))
translate_keys = {0: vec(0, 0, 0), 2: vec(1, 1, 0), 4: vec(0, 0, 0)}
rotate_keys = {
0: quaternion(),
2: quaternion_from_euler(180, 45, 90),
3: quaternion_from_euler(180, 0, 180),
4: quaternion()
}
scale_keys = {0: 1, 2: 0.5, 4: 1}
# keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
base_node = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
base_node.add(base_shape, rotate1)
viewer.add(base_node)
# meshes = load_textured("cube/cube/cube.obj")
# meshes = load("suzanne.obj")
# for m in meshes:
# keynode.add(m)
# viewer.add(keynode)
# start rendering loop
viewer.run()
def add_hierarchical_banner():
# ----------SHAPES---------------
cube = Shape('resources/cube.obj')
left_h = Node(
transform=translate(x=0.5, y=0, z=1.5) @ scale(0.02, 0.2, 0.02))
left_h.add(cube)
right_h = Node(
transform=translate(x=0.78, y=0, z=1.5) @ scale(0.02, 0.2, 0.02))
right_h.add(cube)
main_branch = Node(
transform=translate(x=0.64, y=0.05, z=1.5) @ scale(0.3, 0.1, 0.02))
main_branch.add(cube)
transform_left_h = Node()
transform_left_h.add(left_h)
transform_right_h = Node()
transform_right_h.add(right_h)
transform_main_branch = Node(transform=translate(x=-0.4, y=-0.32, z=-0.2)
@ rotate(axis=(0, 1, 0), angle=30))
transform_main_branch.add(main_branch, transform_left_h, transform_right_h)
return transform_main_branch
def configure(self): ''' Configure lidar. Called once after construction of Lidar instance. ''' # normalize lookAt vector self.lookAt = self.lookAt / np.linalg.norm(self.lookAt) # calculate convergence point self.r = np.sqrt(self.aperture / np.pi) self.convergence = self.position - self.r / np.tan(self.fov) * self.lookAt # calculate the rotation matrix z = np.array([0, -1, 0]) n = self.lookAt[:3] self.rotationMatrix = np.eye(4) axis = np.cross(z, n) if np.abs(np.dot(axis, axis)) > 0: degrees = np.arccos(np.dot(n, z)) degrees = np.rad2deg(degrees) self.rotationMatrix[:3, :3] = transform.rotate(degrees, axis) # auxiliary self.cosFov = np.cos(self.fov) self.sigmaBeam2 = - 0.5 / np.log(self.fractionAtRadius)
def __init__(self, shader):
self.shader = shader
# triangle position buffer
position = np.array(((0, .5, 0), (.5, -.5, 0), (-.5, -.5, 0)), 'f')
color = np.array(((1, 0, 0), (0, 1, 0), (0, 0, 1)), 'f')
rot = rotate((0, 0, 1), 30)
# TODO
self.glid = GL.glGenVertexArrays(1) # create OpenGL vertex array id
GL.glBindVertexArray(self.glid) # activate to receive state below
self.buffers = [GL.glGenBuffers(1)
] # create buffer for position attrib
# bind the vbo, upload position data to GPU, declare its size and type
GL.glEnableVertexAttribArray(0) # assign to layout = 0 attribute
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[0])
GL.glBufferData(GL.GL_ARRAY_BUFFER, position, GL.GL_STATIC_DRAW)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, False, 0, None)
self.buffers += [GL.glGenBuffers(1)]
# bind the vbo, upload position data to GPU, declare its size and type
GL.glEnableVertexAttribArray(1) # assign to layout = 1 attribute
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[1])
GL.glBufferData(GL.GL_ARRAY_BUFFER, color, GL.GL_STATIC_DRAW)
GL.glVertexAttribPointer(1, 3, GL.GL_FLOAT, False, 0, None)
# cleanup and unbind so no accidental subsequent state update
GL.glBindVertexArray(0)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
# color state of the object
self.color = (0.6, 0.6, 0.9)
def draw(self, projection, view, model, win=None, **param):
assert win is not None
self.angle += 2 * int(glfw.get_key(win, self.key_up) == glfw.PRESS)
self.angle -= 2 * int(glfw.get_key(win, self.key_down) == glfw.PRESS)
self.transform = rotate(self.axis, self.angle)
super().draw(projection, view, model, win=win, **param)
def image_synthesis(objects, observer):
tr = rotate(translate(matrix(1), observer.p[:3]), (0, 0, 0), observer[1:])
objects = [obj.transform(tr) for obj in objects]
for ob in objects:
print(ob.points)
return [
obj.polygons for obj in objects if all([all([p.x > d, -Ex <= p.z <= Ex, -Ey <= p.y <= Ey]) for p in obj.points])
]
def add_hierarchical_model():
# ----------SHAPES---------------
sphere_mesh = Shape('resources/sphere.obj')
head_shape = Node(
transform=translate(x=1, y=-0.2, z=0.03) @ scale(0.2, 0.18, 0.1))
head_shape.add(sphere_mesh)
cylinder = Shape('resources/cylinder.obj')
leg_shape1 = Node(
transform=translate(x=1, y=-0.25, z=0.05) @ scale(0.01, 0.05, 0.01))
leg_shape1.add(cylinder)
leg_shape2 = Node(
transform=translate(x=0.92, y=-0.25, z=0.05) @ scale(0.01, 0.05, 0.01))
leg_shape2.add(cylinder)
foot_shape1 = Node(transform=translate(x=0.92, y=0.025, z=0.291) @ scale(
0.009, 0.025, 0.01))
foot_shape1.add(cylinder)
foot_shape2 = Node(
transform=translate(x=1, y=0.025, z=0.291) @ scale(0.009, 0.025, 0.01))
foot_shape2.add(cylinder)
# ------- Node Connections---------
transform_foot2 = Node(transform=rotate(axis=(1, 0, 0), angle=89))
transform_foot2.add(foot_shape2)
transform_foot1 = Node(transform=rotate(axis=(1, 0, 0), angle=89))
transform_foot1.add(foot_shape1)
transform_leg2 = Node(transform=translate(x=0, y=0, z=0))
transform_leg2.add(leg_shape2, transform_foot2)
transform_leg1 = Node(transform=translate(x=0, y=0, z=0))
transform_leg1.add(leg_shape1, transform_foot1)
transform_body = Node(transform=translate(x=-0.4, y=0, z=0.8))
transform_body.add(transform_leg1, transform_leg2, head_shape)
trans_node = TranslationControlNode(glfw.KEY_W, glfw.KEY_S, glfw.KEY_A,
glfw.KEY_D)
trans_node.add(transform_body)
return trans_node
def draw(self, projection, view, model, win=None, **param):
assert win is not None
self.angle += 0.2 * int(glfw.get_key(win, self.key_up) == glfw.PRESS)
self.angle -= 0.2 * int(glfw.get_key(win, self.key_down) == glfw.PRESS)
#model = model @ param.get('transf', identity())
self.transform = rotate(self.axis, self.angle)
# call Node's draw method to pursue the hierarchical tree calling
super().draw(projection, view, model, win=win, **param)
def robot_arm():
# construct our robot arm hierarchy for drawing in viewer
cylinder = Cylinder() # re-use same cylinder instance
limb_shape = Node(transform=scale(0.1, 0.5, 0.1),
name='limb shape') # make a thin cylinder
limb_shape.add(cylinder) # common shape of arm and forearm
forearm_node = Node(transform=translate(0, 0.5, 0), name='forearm node')
forearm_node.add(limb_shape)
rot_forearm_node = RotationControlNode(glfw.KEY_LEFT,
glfw.KEY_RIGHT, (1, 0, 0),
transform=rotate((1, 0, 0), 45),
children=[forearm_node],
name='rot forearm node')
move_forearm_node = Node(transform=translate(0, 1, 0),
children=[rot_forearm_node],
name='move forearm node')
# robot arm rotation with phi angle
arm_node = Node(transform=translate(0, .5, 0), name='arm node')
arm_node.add(limb_shape)
rot_arm_node = RotationControlNode(glfw.KEY_UP,
glfw.KEY_DOWN, (1, 0, 0),
children=[arm_node, move_forearm_node],
name='rot arm node')
move_arm_node = Node(children=[rot_arm_node], name='move arm node')
base_shape_size = Node(transform=scale(.5, .1, .5),
children=[cylinder],
name='base shape size')
base_shape_rot = RotationControlNode(
glfw.KEY_P,
glfw.KEY_O, (0, 1, 0),
transform=rotate((0, 0, 1), 0),
children=[base_shape_size, move_arm_node],
name='base rotation')
root_node = Node(children=[base_shape_rot], name='base shape')
return root_node
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# default color shader
shader = Shader("color.vert", "color.frag")
# think about it: we can re-use the same cylinder instance!
cylinder = Cylinder(shader)
# make a flat cylinder
base_shape = Node(transform=scale(1, 0.7, 1))
base_shape.add(cylinder) # shape of robot base
# make a thin cylinder
arm_shape = Node(transform=translate(0, 3, 0) @ scale(0.1, 2.4, 0.1))
arm_shape.add(cylinder) # shape of arm
# make a thin cylinder
forearm_shape = Node(transform=translate(0, 7, 0) @ scale(0.1, 1.8, 0.1))
forearm_shape.add(cylinder) # shape of forearm
theta = 45.0 # base horizontal rotation angle
phi1 = 45.0 # arm angle
phi2 = 20.0 # forearm angle
transform_forearm = Node(transform=rotate((0.6, 0.5, 1), phi2))
transform_forearm.add(forearm_shape)
transform_arm = Node(transform=rotate((0.3, 0.1, 0.9), phi1))
transform_arm.add(arm_shape, transform_forearm)
transform_base = Node(transform=rotate((0.9, 0.1, 0.2), theta))
transform_base.add(base_shape, transform_arm)
viewer.add(transform_base)
# place instances of our basic objects
# viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file, shader)])
# if len(sys.argv) < 2:
# print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
# ' format supported by assimp.' % (sys.argv[0],))
# start rendering loop
viewer.run()
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
cylinder = Cylinder()
# base
base_shape = Node(transform=scale(1, 0.25, 1))
base_shape.add(cylinder)
# arm
arm_shape = Node(transform=(translate(0, 1, 0) @ scale(0.5, 1, 0.5)))
arm_shape.add(cylinder)
# forearm
forearm_shape = Node(transform=(translate(0, 1, 0) @ scale(0.25, 1, 0.25)))
forearm_shape.add(cylinder)
# ---- construct our robot arm hierarchy ---------------------------
theta = 0 # base horizontal rotation angle
phi1 = 0 # arm angle
phi2 = 45 # forearm angle
transform_forearm = Node(
transform=translate(0, 2, 0) @ rotate((1, 0, 0), phi2))
transform_forearm.add(forearm_shape)
transform_arm = Node(transform=rotate((1, 1, 0), phi1))
transform_arm.add(arm_shape, transform_forearm)
transform_base = Node(transform=rotate((1, 1, 0), theta))
transform_base.add(base_shape, transform_arm)
viewer.add(transform_base)
# place instances of our basic objects
# viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file)])
if len(sys.argv) < 2:
print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
' format supported by pyassimp.' % (sys.argv[0], ))
# start rendering loop
viewer.run()
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# default color shader
shader = Shader("color.vert", "color.frag")
# ---- let's make our shapes ---------------------------------------
# think about it: we can re-use the same cylinder instance!
cylinder = Cylinder(shader)
# make a flat cylinder
base_shape = Node(transform=scale(1, 0.75, 1))
base_shape.add(cylinder) # shape of robot base
# make a thin cylinder
arm_shape = Node(transform=translate(0, 1.5, 0) @ scale(0.5, 1.5, 0.5))
arm_shape.add(cylinder) # shape of arm
# make a thin cylinder
forearm_shape = Node(transform=translate(0, 1, 0) @ scale(0.5, 1, 0.5))
forearm_shape.add(cylinder) # shape of forearm
# ---- construct our robot arm hierarchy ---------------------------
theta = 45.0 # base horizontal rotation angle
phi1 = 20.0 # arm angle
phi2 = 80.0 # forearm angle
transform_forearm = Node(
transform=translate(0, 3, 0) @ rotate((0, 0, 1), phi2))
transform_forearm.add(forearm_shape)
transform_arm = Node(
transform=translate(0, 0.75, 0) @ rotate((0, 0, 1), phi1))
transform_arm.add(arm_shape, transform_forearm)
transform_base = Node(transform=rotate((0, 1, 0), theta))
transform_base.add(base_shape, transform_arm)
viewer.add(transform_base)
# start rendering loop
viewer.run()
def draw(self, projection, view, model, win=None, **param):
self.angle += self.speed
if glfw.get_key(
win, glfw.KEY_SPACE
) == glfw.PRESS: # set angle to 0 to restart the animation
self.angle = 0
if self.angle < 361: # stop on a full rotation
self.transform = rotate(self.axis, self.angle)
super().draw(projection, view, model, win=win, **param)
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# cylinder_node = Node(name='my_cylinder', transform=translate(-1, 0, 0), color=(1, 0, 0.5, 1))
# cylinder_node.add(Cylinder())
# viewer.add(cylinder_node)
# place instances of our basic objects
# viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file)])
# construct our robot arm hierarchy for drawing in viewer
cylinder = Cylinder() # re-use same cylinder instance
limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder
forearm_node = Node(
transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate(
0, 0, 0)) # robot arm rotation with phi angle
forearm_node.add(limb_shape)
# limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder
limb_shape.add(cylinder) # common shape of arm and forearm
arm_node = Node(transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate(
0, 0, 0)) # robot arm rotation with phi angle
arm_node.add(limb_shape, forearm_node)
# make a flat cylinder
base_shape = Node(transform=scale(1, 0.5, 1), children=[cylinder])
base_node = Node(transform=rotate(axis=vec(
0, 1, 0), angle=45)) # robot base rotation with theta angle
base_node.add(base_shape, arm_node)
viewer.add(base_node)
# if len(sys.argv) < 2:
# print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
# ' format supported by pyassimp.' % (sys.argv[0],))
# start rendering loop
viewer.run()
def key_handler(self, key):
self.angle += 0.5 * int(key == self.key_left)
self.angle -= 0.5 * int(key == self.key_right)
self.x += 1 * (key == self.key_fwd)
self.x -= 1 * (key == self.key_bwd)
self.z += 1 * (key == self.key_up)
self.z -= 1 * (key == self.key_down)
self.is_follow = not self.is_follow * (key == self.key_f)
# self.transform =
self.transform = translate(0, self.z, self.x) @ rotate(
self.axis, self.angle)
super().key_handler(key)
def draw(self, projection, view, model):
GL.glUseProgram(self.shader.glid)
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
color_loc = GL.glGetUniformLocation(self.shader.glid, 'color')
GL.glUniform3fv(color_loc, 1, self.color)
matrix_loc = GL.glGetUniformLocation(self.shader.glid, 'matrix')
GL.glUniformMatrix4fv(matrix_loc, 1, True, rotate(vec(1, 1, 1), 45))
def construct_houses(self, shader_1, shader_2, transform=identity()):
big_houses = []
for j in range(0, 5, 2):
if (j % 4 == 2):
for i in range(0, 5, 2):
big_houses.append(
add_object(self.big_house,
transform=transform @ translate(
100 * i, 100 * j, 0) @ rotate(
(0, 0, 1),
random() * 180)))
elif (j % 4 == 0):
for i in range(1, 4, 2):
big_houses.append(
add_object(self.big_house,
transform=transform @ translate(
100 * i, 100 * j, 0) @ rotate(
(0, 0, 1),
random() * 90)))
else:
pass
#self.children.extend([add_object(self.trees['autumn_tree'], shader_2, transform=transform@translate(100*3, 100*1, 0)@scale(50))])
self.children.extend(big_houses)
def __init__(self,
planete,
vrot,
periode1,
vecDeb,
scale,
vdirec,
periode2,
rayon,
name='',
lumineux=False,
**kwargs):
if (name == '' and lumineux == True):
print("Un objet lumineux doit avoir un nom")
vrot2 = np.cross(vecDeb, vdirec)
if (np.linalg.norm(vecDeb) == 0):
translate = {0: vec(0, 0, 0), 1: vec(0, 0, 0)}
else:
translate = {
0: vecDeb,
(periode2 / 4): rotate(vrot2, 90)[:3, :3] @ vecDeb,
(periode2 / 2): rotate(vrot2, 180)[:3, :3] @ vecDeb,
(3 * periode2 / 4): rotate(vrot2, 270)[:3, :3] @ vecDeb,
(periode2): vecDeb
}
demi_grand_axe = math.pow(
periode2 * periode2 * 66740 * math.pow(10, 15) /
(2 * np.pi * np.pi), 1 / 3)
rotate2 = {0: quaternion(), 1: quaternion()}
scale2 = {0: 1, 2: 1, 4: 1}
self.lumineux = lumineux
if (lumineux == True):
kwargs['light'] = (0, 0, 0)
super().__init__(translate, rotate2, scale2, name, lerpCircle,
**kwargs)
planeteP = Planete(planete, vrot, periode1, scale, rayon)
self.add(planeteP)
def draw(self, projection, view, model, color_shader, color, scaler,
rotater):
GL.glUseProgram(color_shader.glid)
my_color_location = GL.glGetUniformLocation(color_shader.glid, 'color')
# hard coded color : (0.6, 0.6, 0.9)
GL.glUniform3fv(my_color_location, 1, color)
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
GL.glUniformMatrix4fv(
matrix_location, 1, True,
perspective(35, 640 / 480, 0.001, 100) @ translate(0, 0, -1)
@ rotate(vec(0, 1, 0), rotater) @ scale(scaler))
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
GL.glBindVertexArray(0)
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# paramètre de transformation des paramètres
#sol
ground_size = 512
ground_offset = 20
#dinosaure
characters_offset_x = 0
characters_offset_y = -20
characters_offset_z = 0
characters_scale = 15
characters_rotate_deg = 180
#forêt
forest_offset = -15
forest_scale = 1.5
#skybox
Skysphere_scale = 3
characters = Node(
transform=translate(characters_offset_x, characters_offset_y,
characters_offset_z) @ scale(characters_scale)
@ rotate(axis=(0, 1, 0), angle=characters_rotate_deg))
characters.add(*load_skinned("dino/Dinosaurus_roar.dae"))
forest = Node(
transform=translate(0, forest_offset, 0) @ scale(forest_scale))
forest.add(*load_textured("trees9/forest.obj"))
ground = Node(transform=translate(-ground_size >> 1, ground_offset,
-ground_size >> 1))
ground.add(sol(ground_size))
Skysphere = Node(transform=scale(Skysphere_scale))
Skysphere.add(*load_textured("Skysphere/skysphere.obj"))
scene = Node(transform=identity(),
children=[characters, forest, ground, Skysphere])
viewer.add(scene)
viewer.run()
def rotated_mean(N=100):
images = lambda: util.images().pad(100, 100)
angles = lambda: util.images().pad(100, 100).map(transform.PCA_angle)
rotated = lambda: util.seq(transform.rotate(img, ang) for img, ang in zip(images(), angles()))
logger.info("Calculating mean rotated image")
mean_r = util.mean(rotated(), np.zeros((100, 100)))
# distance
d = np.linalg.norm
dist = (d(img - mean_r) for img in util.progress(rotated()))
logger.info(f"Finding {N} farthest away from the mean")
oddities = nlargest(N, zip(dist, util.image_ids()))
logger.info(f"Finished rotated mean outliers")
return oddities
def main():
viewer = Viewer()
# SkyBox
files = [
'resources/skybox/sky_right1.png', 'resources/skybox/sky_left2.png',
'resources/skybox/sky_top3.png', 'resources/skybox/sky_bottom4.png',
'resources/skybox/sky_back6.png', 'resources/skybox/sky_front5.png'
]
txt1 = Skybox_Textured(files)
viewer.add(txt1)
surface = Surface()
surface_base = Node(transform=scale(x=0.7))
surface_base.add(surface)
viewer.add(surface_base)
viewer.add(add_hierarchical_model())
viewer.add(add_hierarchical_banner())
viewer.add(add_ufo_ship())
viewer.add(add_asteroid())
earth_mesh = PhongMesh('resources/Earth1/earth.obj')
earth_base = Node(transform=translate(x=4, y=1.5, z=-7) @ scale(x=0.0033))
earth_base.add(earth_mesh)
rotate_earth = RotatePlanet(axis=(0, 1, 0), speed=0.8)
rotate_earth.add(earth_base)
viewer.add(rotate_earth)
jupiter_mesh = PhongMesh('resources/Jupiter/Jupiter.obj')
jupiter_base = Node(transform=translate(x=-0.6, y=2, z=-10) @ rotate(
axis=(1, 0, 0), angle=90) @ scale(x=0.001))
jupiter_base.add(jupiter_mesh)
rotate_jupiter = RotatePlanet(axis=(0, 1, 0), speed=0.6)
rotate_jupiter.add(jupiter_base)
viewer.add(rotate_jupiter)
sun_mesh = PhongMesh('resources/Sun/Sun.obj')
sun_base = Node(transform=translate(x=-4, y=2, z=-9) @ scale(x=0.0013))
sun_base.add(sun_mesh)
rotate_sun = RotatePlanet(axis=(0, 1, 0), speed=0.4)
rotate_sun.add(sun_base)
viewer.add(rotate_sun)
# Rendering loop
viewer.run()
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
# place instances of our basic objects
# viewer.add(*[mesh for file in sys.argv[1:] for mesh in load_textured(file)])
# viewer.add(robot_arm())
for file in sys.argv[1:]:
for mesh in load_textured(file):
# viewer.add(mesh)
node = Node(children=[mesh])
rotation_node = RotationControlNode(glfw.KEY_P,
glfw.KEY_O, (0, 1, 0),
children=[node],
transform=rotate((0, 0, 1), 0))
viewer.add(rotation_node)
# if len(sys.argv) < 2:
# print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
# ' format supported by pyassimp.' % (sys.argv[0],))
# esfera = Node(children=[*load_textured("cube/cube.obj")])
# node = RotationControlNode(glfw.KEY_P, glfw.KEY_O, (0,1,0), children=[esfera], transform=rotate((0,0,1),0))
# viewer.add(node)
# translate_keys = {0: vec(0, 0, 0), 2: vec(1, 1, 0), 4: vec(0, 0, 0)}
# rotate_keys = {0: quaternion(), 2: quaternion_from_euler(180, 45, 90),
# 3: quaternion_from_euler(180, 0, 180), 4: quaternion()}
# # scale_keys = {0: 1, 2: 0.5, 4: 1}
# scale_keys = {0:1}
# keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
# keynode.add(Cylinder())
# # keynode.add(*load_textured("bunny/bunny.obj"))
# viewer.add(keynode)
# viewer.run()
# translate_keys = {0: vec(0, 0, 0), 2: vec(0, 0, -1)}
# rotate_keys = {0: quaternion()}
# scale_keys = {0: 1}
# keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys)
# keynode.add(Cylinder())
# # keynode.add(*load_textured("bunny/bunny.obj"))
# viewer.add(keynode)
viewer.run()
def draw(self, projection, view, model, color_shader, color):
GL.glUseProgram(color_shader.glid)
# draw triangle as GL_TRIANGLE vertex array, draw array call
GL.glBindVertexArray(self.glid)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
GL.glBindVertexArray(0)
# color as shader uniform (deactivated, not receiving this info in VS)
my_color_location = GL.glGetUniformLocation(color_shader.glid, 'color')
GL.glUniform3fv(my_color_location, 1, color)
# projection transform
projection_transform = frustum(-2, 2, -2, 2, -2, 2)
# triangle transformation
transformation = rotate(vec(1, 0, 0), 25) @ scale(0.7) @ translate(0.4, 0.7, 0)
transformation = transformation @ projection_transform
matrix_location = GL.glGetUniformLocation(color_shader.glid, 'matrix')
GL.glUniformMatrix4fv(matrix_location, 1, True, transformation)
def main():
""" create a window, add scene objects, then run rendering loop """
viewer = Viewer()
shader = Shader("phong.vert", "phong.frag")
node = Node(transform=rotate((0, 0, 1), 45))
viewer.add(node)
light_dir = (0, -1, 0)
node.add(*[
mesh for file in sys.argv[1:]
for mesh in load_phong_mesh(file, shader, light_dir)
])
if len(sys.argv) != 2:
print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in'
' format supported by assimp.' % (sys.argv[0], ))
# start rendering loop
viewer.run()
def on_key(self, _win, key, _scancode, action, _mods):
""" 'Q' or 'Escape' quits """
if action == glfw.PRESS or action == glfw.REPEAT:
if key == glfw.KEY_ESCAPE or key == glfw.KEY_Q:
glfw.set_window_should_close(self.win, True)
if(key == glfw.KEY_LEFT):
self.camera.SetPosition(self.camera.position + vec(-1, 0, 0) * 0.05)
if(key == glfw.KEY_RIGHT):
self.camera.SetPosition(self.camera.position + vec(1, 0, 0) * 0.05)
if(key == glfw.KEY_UP):
self.camera.SetPosition(self.camera.position + vec(0, 1, 0) * 0.05)
if(key == glfw.KEY_DOWN):
self.camera.SetPosition(self.camera.position + vec(0, -1, 0) * 0.05)
if(key == glfw.KEY_R):
self._LightDirection = (rotate(vec(0, 1, 0), 0.5) @ vec(self._LightDirection[0], self._LightDirection[1], self._LightDirection[2], 1))[0:3]
for drawable in self.drawables:
if hasattr(drawable, 'key_handler'):
drawable.key_handler(key)
def update(self, acceleration, time, detector, precision, stephit=1):
self.momentum += acceleration
self.position += self.momentum / precision
deflect = detector.deposit(self.position, self.id)
if (np.fabs(deflect) > 0):
self.momentum = rotate(self.momentum, deflect)
if ((time % stephit == 0) &
(np.linalg.norm(self.position) > self.traceMin)):
self.history = self.history.append(pd.DataFrame({
'particle': [self.id],
'hit': [time],
'layer':
self.layer,
'iphi':
self.iphi,
'x': [self.position[0]],
'y': [self.position[1]]
}),
ignore_index=True)
pass
def draw(self, projection, view, model, win=None, **_kwargs):
# GL.glDepthMask(GL.GL_FALSE)
GL.glDepthFunc(
GL.GL_LEQUAL
) # change depth function so depth test passes when values are equal to depth buffer's content
GL.glUseProgram(self.shader.glid)
# projection geometry
loc = GL.glGetUniformLocation(self.shader.glid, 'view')
mul = np.array([[1, 1, 1, 0], [1, 1, 1, 0], [1, 1, 1, 0], [1, 1, 1,
1]])
no_translation = view * mul # to remove translation of the camera
# rotate the camera around y axis over time stops when time>12
# when time is reset to 0 (with the Space bar) it starts rotating again
time = glfw.get_time()
if time <= 12:
rotation_matrix = rotate(axis=(0, 1, 0), angle=30 * time)
no_translation = no_translation @ rotation_matrix
GL.glUniformMatrix4fv(loc, 1, True, no_translation)
loc1 = GL.glGetUniformLocation(self.shader.glid, 'projection')
GL.glUniformMatrix4fv(loc1, 1, True, projection)
# texture access setups
loc2 = GL.glGetUniformLocation(self.shader.glid, 'cubeMap')
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_CUBE_MAP, self.texture.glid)
GL.glUniform1i(loc2, 0)
self.vertex_array.execute(GL.GL_TRIANGLES)
GL.glDepthFunc(GL.GL_LESS)
# set depth function back to default
# GL.glDepthMask(GL.GL_TRUE);
# leave clean state for easier debugging
GL.glBindTexture(GL.GL_TEXTURE_CUBE_MAP, 0)
GL.glUseProgram(0)
def wheat_variety_analysis(microscopy_collection, output_dir):
"""Analyse all series in microscopy collection."""
csv_fpath = os.path.join(output_dir, "cell_lengths.csv")
with open(csv_fpath, "w") as csv_fh:
write_csv_header(csv_fh)
for s in microscopy_collection.series:
print("Analysing series {}".format(s))
# Write the CSV file.
image = get_image(microscopy_collection, s)
segmentation, angle = segment(image)
for l in get_lengths(segmentation):
write_csv_row(s, l, csv_fh)
# Create annotated image.
image = rotate(image, angle)
annotation = annotate_segmentation(image, segmentation)
im_fpath = os.path.join(output_dir, "series_{:03d}.png".format(s))
with open(im_fpath, "wb") as im_fh:
im_fh.write(annotation.png())
def segment(image):
"""Return a segmented image and rotation angle."""
angle = find_angle(image)
image = rotate(image, angle)
mask = create_mask(image)
watershed_mask = equalize_adaptive_clahe(image)
watershed_mask = smooth_gaussian(watershed_mask, sigma=(1, 0))
watershed_mask = threshold_otsu(watershed_mask)
watershed_mask = apply_mask(watershed_mask, mask)
n = 20
selem = np.array([0, 1, 0] * n).reshape((n, 3))
seeds = erosion_binary(watershed_mask, selem=selem)
seeds = apply_mask(seeds, vertical_cuts(watershed_mask))
seeds = remove_small_objects(seeds)
seeds = connected_components(seeds, connectivity=1, background=0)
segmentation = watershed_with_seeds(image, seeds, mask=watershed_mask)
segmentation = remove_cells_touching_border(segmentation, image)
segmentation = remove_cells_touching_border(segmentation, mask)
segmentation = remove_tilted_cells(segmentation)
return segmentation, angle
def annotate(image):
"""Return annotated image."""
segmentation, angle = segment(image)
image = rotate(image, angle)
return annotate_segmentation(image, segmentation)
train = load_data()
multiplier = 4
original_size = train[0].shape[0]
final_size = multiplier * original_size
print("Creating dataset of size {}".format(final_size))
x = []
y = numpy.array([])
for run in range(multiplier):
for i in range(original_size):
image = train[0][i]
label = train[1][i]
image = transform.elastic(image, sigma, alpha)
rotation = random.randint(-30, 30)
if label in (1, 7):
rotation /= 2
image = transform.rotate(image, rotation)
image = transform.sigmoid(image, 12)
x.append(image)
y = numpy.append(y, label)
if len(x) % 1000 == 0:
print("Image {}".format(len(x)))
ds = (numpy.vstack(x), y)
prefix = "mnist_elastic_{}_{}".format(sigma, alpha)
suffix = "{}k".format(int(final_size / 1000))
numpy.save("{}_x_{}".format(prefix, suffix), ds[0])
numpy.save("{}_y_{}".format(prefix, suffix), ds[1])
def update(self, elapsed_time):
if self.rotate_light:
angle = 45 * elapsed_time
light_position = rotate(
(1, 0, 1), angle) @ vec(*self.light_position, 1)
def __init__(self, self_dict):
# get arguments
for arg in self_dict:
setattr(self, arg, self_dict[arg])
self.rng = np.random.RandomState(self.seed)
tf.set_random_seed(self.seed)
# network setting
self.graph = tf.Graph()
self.sess = tf.InteractiveSession(graph=self.graph)
self.model_path = self.style_path + "/" + self.model_path
with tf.gfile.GFile(self.model_path, 'rb') as f:
graph_def = tf.GraphDef()
graph_def.ParseFromString(f.read())
# fix checkerboard artifacts: ksize should be divisible by the stride size
# but it changes scale
if self.pool1:
for n in graph_def.node:
if 'conv2d0_pre_relu/conv' in n.name:
n.attr['strides'].list.i[1:3] = [1, 1]
# density input
# shape: [D,H,W]
d_shp = [None, None, None]
self.d = tf.placeholder(dtype=tf.float32, shape=d_shp, name='density')
# add batch dim / channel dim
# shape: [1,D,H,W,1]
d = tf.expand_dims(tf.expand_dims(self.d, axis=0), axis=-1)
######
# sequence stylization
self.d_opt = tf.placeholder(dtype=tf.float32, name='opt')
if 'field' in self.field_type:
if self.w_field == 1:
self.c = 1
elif self.w_field == 0:
self.c = 3
else:
self.c = 4 # scalar (1) + vector field (3)
elif 'density' in self.field_type:
self.c = 1 # scalar field
else:
self.c = 3 # vector field
if 'field' in self.field_type:
d_opt = self.d_opt[:, :, ::-1] * tf.to_float(
tf.shape(self.d_opt)[2])
if self.w_field == 1:
self.v_ = grad(d_opt)
elif self.w_field == 0:
self.v_ = curl(d_opt)
else:
pot = d_opt[..., 0, None]
strf = d_opt[..., 1:]
self.v_p = grad(pot)
self.v_s = curl(strf)
self.v_ = self.v_p * self.w_field + self.v_s * (1 -
self.w_field)
v = self.v_[:, :, ::-1]
vx = v[..., 0] / tf.to_float(tf.shape(v)[3])
vy = -v[..., 1] / tf.to_float(tf.shape(v)[2])
vz = v[..., 2] / tf.to_float(tf.shape(v)[1])
v = tf.stack([vz, vy, vx], axis=-1)
d = advect(d, v, order=self.adv_order, is_3d=True)
elif 'velocity' in self.field_type:
v = self.d_opt # [1,D,H,W,3]
d = advect(d, v, order=self.adv_order, is_3d=True)
else:
# stylize by addition
d += self.d_opt # [1,D,H,W,1]
self.b_num = self.v_batch
######
######
# velocity fields to advect gradients [B,D,H,W,3]
if self.window_size > 1:
self.v = tf.placeholder(dtype=tf.float32, name='velocity')
self.g = tf.placeholder(dtype=tf.float32, name='gradient')
self.adv = advect(self.g, self.v, order=self.adv_order, is_3d=True)
######
# value clipping (d >= 0)
d = tf.maximum(d, 0)
# stylized 3d result
self.d_out = d
if self.rotate:
d, self.rot_mat = rotate(d) # [b,D,H,W,1]
# compute rotation matrices
self.rot_mat_, self.views = rot_mat(self.phi0,
self.phi1,
self.phi_unit,
self.theta0,
self.theta1,
self.theta_unit,
sample_type=self.sample_type,
rng=self.rng,
nv=self.n_views)
if self.n_views is None:
self.n_views = len(self.views)
print('# vps:', self.n_views)
assert (self.n_views % self.v_batch == 0)
# render 3d volume
transmit = tf.exp(-tf.cumsum(d[:, ::-1], axis=1) * self.transmit)
d = tf.reduce_sum(d[:, ::-1] * transmit, axis=1)
d /= tf.reduce_max(d) # [0,1]
# resize if needed
if abs(self.resize_scale - 1) > 1e-7:
h = tf.to_int32(
tf.multiply(float(self.resize_scale),
tf.to_float(tf.shape(d)[1])))
w = tf.to_int32(
tf.multiply(float(self.resize_scale),
tf.to_float(tf.shape(d)[2])))
d = tf.image.resize_images(d, size=[h, w])
# change the range of image to [0-255]
self.d_img = tf.concat([d * 255] * 3, axis=-1) # [B,H,W,3]
# plug-in to the pre-trained network
imagenet_mean = 117.0
d_preprocessed = self.d_img - imagenet_mean
tf.import_graph_def(graph_def, {'input': d_preprocessed})
self.layers = [
op.name for op in self.graph.get_operations()
if op.type == 'Conv2D' and 'import/' in op.name
]
def rotate(self, angles):
self.mat = tr.rotate(self.mat, self.c, angles)
def align(image):
"""Return an aligned image."""
angle = find_angle(image)
image = rotate(image, angle)
return image
