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