def on_timer(self, ev): millis_passed = int(100 * (self.model.t % 1)) sec_passed = int(self.model.t % 60) min_passed = int(self.model.t // 60) self.hook.transform.reset() self.hook.transform = transforms.MatrixTransform() self.hook.transform.scale((self.hook_length, self.hook_height, 0.001)) self.hook.transform.translate( [self.hook_length / 2.016 + self.scale * self.model.x, 0.0]) self.hook.transform.translate(self.center) # Apply the necessary transformations to the rod self.rod.transform.reset() self.rod.transform.scale( (self.rod_width, self.scale * self.model.l, 0.0001)) self.rod.transform.translate([0.0, self.scale * self.model.l / 2.0]) self.rod.transform.rotate(np.rad2deg(self.model.theta), (0, 0, 1)) self.rod.transform.translate([self.scale * self.model.x, 0.0]) self.rod.transform.translate(self.center) # Update the timer with how long it's been self.text.text = '{:0>2d}:{:0>2d}.{:0>2d}'.format( min_passed, sec_passed, millis_passed) self.update() self.model.do_time_step()
def update(self, t, crazyflies): if len(self.cfs) == 0: verts, faces, normals, nothin = io.read_mesh(CF_MESH_PATH) for i, cf in enumerate(crazyflies): color = cf.ledRGB mesh = scene.visuals.Mesh(parent=self.view.scene, vertices=verts, faces=faces, color=color, shading='smooth') mesh.transform = transforms.MatrixTransform() self.cfs.append(mesh) self.color_cache.append(color) for i in range(0, len(self.cfs)): x, y, z = crazyflies[i].position() roll, pitch, yaw = crazyflies[i].rpy() self.cfs[i].transform.reset() self.cfs[i].transform.rotate(90, (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(roll), (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(pitch), (0, 1, 0)) self.cfs[i].transform.rotate(math.degrees(yaw), (0, 0, 1)) self.cfs[i].transform.scale((0.001, 0.001, 0.001)) self.cfs[i].transform.translate((x, y, z)) # vispy does not do this check color = crazyflies[i].ledRGB if color != self.color_cache[i]: self.color_cache[i] = color self.cfs[i].color = color # sets dirty flag self.canvas.app.process_events()
def add_mesh_data_to_view(mdata, view, want_faces=True, want_points=True, want_lines=True, transform=transforms.MatrixTransform()): color = mdata.get('color', 'g') if isinstance(color, str) and color == 'random': color = np.random.random(3).tolist() else: color = Color(color).rgb.tolist() res = Attributize() res.lines = [] res.objs = [] if want_lines and 'lines' in mdata: for polyline in mdata.lines: if isinstance(polyline, Attributize): width = polyline.get('width', 1) method = 'gl' if width > 1: method = 'gl' l = Line( pos=np.array(np.array(polyline.polyline)), antialias=True, method=method, color=np.array(polyline.colors), width=width,) else: l = Line(pos=np.array(np.array(polyline)), antialias=False, method='gl', color=color) l.transform = transform view.add(l) res.lines.append(l) res.objs.append(l) if want_points and mdata.get('points', None) is not None: scatter = Markers() #mdata.points = np.array(( # (10.928140, -51.417831, -213.253723), # (0.000000, -46.719570, -205.607208), # (0.000000, -53.499737, -215.031876), # (0.000000, -69.314308, -223.780746), # (0.000000, -89.549263, -170.910568),)) #mdata.points = np.array(((-12.138942,-55.812309,-217.007050),(10.928140,-51.417831,-213.253723),(-7.289741,-43.585541,-200.506531))) points_color = mdata.get('points_color', color) points_size = mdata.get('points_size', 10) points = np.array(mdata.points) #print('PLOTTING ', points, points_size) if len(points) == 0: return scatter.set_data(points, edge_color=None, face_color=points_color, size=points_size) scatter.transform = transform view.add(scatter) res.objs.append(scatter) res.points = scatter if want_faces and 'mesh' in mdata: mesh = Mesh(meshdata=mdata.mesh, color=color + [0.7]) mesh.transform = transform view.add(mesh) res.mesh = mesh res.objs.append(mesh) return res
def __init__(self, rank, which_pos, how_many_seg, to_scale): super().__init__(radius=0.075 , method='latitude' , color=(1, 0, 0, 0.5) if rank > 50 else (1, 1, 1, 0.5) ) self.transform = transforms.MatrixTransform() self.transform.translate( to_scale * (which_pos - how_many_seg//2))
def __init__(self, view, radius, face_color, edge_color): super(mbSphere, self).__init__(radius, color=face_color, edge_color=edge_color, parent=view, method='ico') self.transform = transforms.MatrixTransform()
def __init__(self): app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400)) self.cube = BoxVisual(1.0, 0.5, 0.25, color='red', edge_color='black') self.cube.transform = transforms.MatrixTransform() self.cube.transform.scale((100, 100, 0.001)) self.cube.transform.translate((200, 200)) self.quaternion = Quaternion() self.show()
def __init__(self, *args, **kwargs): self.cube = CubeVisual(size=(0.8, 0.5, 0.5), color='red', edge_color="k") self.theta = 0 self.phi = 0 self.cube_transform = transforms.MatrixTransform() self.cube.transform = self.cube_transform self._timer = Timer('auto', connect=self.on_timer, start=True) SceneCanvas.__init__(self, *args, **kwargs)
def _define_transformation(self): sh = self._sh r90 = vist.MatrixTransform() r90.rotate(90, (0, 0, 1)) rx180 = vist.MatrixTransform() rx180.rotate(180, (1, 0, 0)) # Sagittal transformation : norm_sagit = vist.STTransform(scale=(1. / sh[1], 1. / sh[2], 1.), translate=(-1., 0., 0.)) tf_sagit = vist.ChainTransform([norm_sagit, r90, rx180]) self._im_sagit.transform = tf_sagit # Coronal transformation : norm_coron = vist.STTransform(scale=(1. / sh[0], 1. / sh[2], 1.), translate=(0., 0., 0.)) tf_coron = vist.ChainTransform([norm_coron, r90, rx180]) self._im_coron.transform = tf_coron # Axial transformation : norm_axis = vist.STTransform(scale=(2. / sh[1], 2. / sh[0], 1.), translate=(-1., 0., 0.)) tf_axial = vist.ChainTransform([norm_axis, rx180]) self._im_axial.transform = tf_axial
def __init__(self, tensor_data): self.canvas = CostumizedCanvas(keys='interactive') self.view = self.canvas.central_widget.add_view() self.view.camera = 'turntable' #self.view.camera = 'fly' self.canvas.central_widget.remove_widget(self.view) self.canvas.central_widget.add_widget(self.view) tensor_data.register(self) self.axis = scene.visuals.XYZAxis(parent=self.view.scene) self.axis.transform = transforms.MatrixTransform() self.axis.transform.translate((-1, -1, -1)) self.shower_units = []
def test_st_transform(): # Check that STTransform maps exactly like MatrixTransform pts = np.random.normal(size=(10, 4)) scale = (1, 7.5, -4e-8) translate = (1e6, 0.2, 0) st = tr.STTransform(scale=scale, translate=translate) at = tr.MatrixTransform() at.scale(scale) at.translate(translate) assert np.allclose(st.map(pts), at.map(pts)) assert np.allclose(st.inverse.map(pts), at.inverse.map(pts))
def __init__(self, parent=None): """Init.""" # Add PanZoom cameras to each box : parent['Sagit'].camera = scene.PanZoomCamera() parent['Coron'].camera = scene.PanZoomCamera() parent['Axial'].camera = scene.PanZoomCamera() # Define three images (Sagittal, Coronal, Axial) : kwargs_im = {'interpolation': 'bilinear'} self._cspSagit = visu.Image(name='SagitSplit', **kwargs_im) self._cspCoron = visu.Image(name='CoronSplit', **kwargs_im) self._cspAxial = visu.Image(name='AxialSplit', **kwargs_im) # Define three text object : kwargs_txt = { 'color': 'white', 'font_size': 2, 'anchor_x': 'left', 'anchor_y': 'bottom' } self._cspTxtSagit = visu.Text(text='Sagit', **kwargs_txt) self._cspTxtCoron = visu.Text(text='Coron', **kwargs_txt) self._cspTxtAxial = visu.Text(text='Axial', **kwargs_txt) # Add each image to parent : parent['Sagit'].add(self._cspSagit) parent['Coron'].add(self._cspCoron) parent['Axial'].add(self._cspAxial) # Add text to parent : parent['Sagit'].add(self._cspTxtSagit) parent['Coron'].add(self._cspTxtCoron) parent['Axial'].add(self._cspTxtAxial) # Add transformations : r90 = vist.MatrixTransform() r90.rotate(90, (0, 0, 1)) r180 = vist.MatrixTransform() r180.rotate(180, (0, 0, 1)) self._cspSagit.transform = r90 self._cspCoron.transform = r90 self._cspAxial.transform = r180 self._parent_sp = parent
def __init__(self): app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400)) self.cube = BoxVisual(1.0, 0.5, 0.25, color='red', edge_color="k") self.theta = 0 self.phi = 0 # Create a TransformSystem that will tell the visual how to draw self.cube_transform = transforms.MatrixTransform() self.cube.transform = self.cube_transform self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def __init__(self, connection, orientation): self.con = connection self.orientation = orientation app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400)) self.cube = CubeVisual((7.0, 4.0, 0.3), color=Color(color='grey', alpha=0.1, clip=False), edge_color="black") # Create a TransformSystem that will tell the visual how to draw self.cube_transform = transforms.MatrixTransform() self.cube.transform = self.cube_transform self._timer = app.Timer('0.05', connect=self.on_timer, start=True) self.show()
def update(self, t, crazyflies): if len(self.cfs) == 0: verts, faces, normals, nothin = io.read_mesh(CF_MESH_PATH) for i, cf in enumerate(crazyflies): color = cf.ledRGB mesh = scene.visuals.Mesh( parent=self.view.scene, vertices=verts, faces=faces, color=color, shading="smooth", ) mesh.light_dir = (0.1, 0.1, 1.0) mesh.shininess = 0.01 mesh.ambient_light_color = [0.5] * 3 mesh.transform = transforms.MatrixTransform() self.cfs.append(mesh) self.color_cache.append(color) positions = np.stack(cf.position() for cf in crazyflies) for i in range(0, len(self.cfs)): x, y, z = crazyflies[i].position() roll, pitch, yaw = crazyflies[i].rpy() self.cfs[i].transform.reset() self.cfs[i].transform.rotate(-90, (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(roll), (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(pitch), (0, 1, 0)) self.cfs[i].transform.rotate(math.degrees(yaw), (0, 0, 1)) self.cfs[i].transform.scale((0.002, 0.002, -0.002)) self.cfs[i].transform.translate(positions[i]) # vispy does not do this check color = crazyflies[i].ledRGB if color != self.color_cache[i]: self.color_cache[i] = color self.cfs[i].color = color # sets dirty flag # Update graph line segments to match new Crazyflie positions. if self.graph is not None: for k, (i, j) in enumerate(self.graph_edges): self.graph_lines[2 * k, :] = positions[i] self.graph_lines[2 * k + 1, :] = positions[j] self.graph.set_data(self.graph_lines) self.canvas.app.process_events()
def __init__(self, parent=None, parent_sp=None, visible=True, cmap='gray'): """Init.""" CrossSectionsSplit.__init__(self, parent_sp) self._visible_cs = visible self._cmap_cs = cmap ####################################################################### # TRANFORMATIONS ####################################################################### # Translations : self._tr_coron = vist.STTransform() self._tr_sagit = vist.STTransform() self._tr_axial = vist.STTransform() # Rotations : rot_m90x = vist.MatrixTransform(rotate(-90, [1, 0, 0])) rot_180x = vist.MatrixTransform(rotate(180, [1, 0, 0])) rot_90y = vist.MatrixTransform(rotate(90, [0, 1, 0])) rot_m90y = vist.MatrixTransform(rotate(-90, [0, 1, 0])) rot_m180y = vist.MatrixTransform(rotate(-180, [0, 1, 0])) rot_90z = vist.MatrixTransform(rotate(90, [0, 0, 1])) # Tranformations : tf_sagit = [self._tr_sagit, rot_90z, rot_m90y, rot_m90x] tf_coron = [self._tr_coron, rot_90z, rot_180x, rot_90y] tf_axial = [self._tr_axial, rot_m180y, rot_90z] ####################################################################### # ELEMENTS ####################################################################### # Create a root node : self._node_cs = scene.Node(name='Cross-Sections') self._node_cs.parent = parent self._node_cs.visible = visible # Axial : self.axial = ImageSection(parent=self._node_cs, name='Axial') self.axial.transform = vist.ChainTransform(tf_axial) # Coronal : self.coron = ImageSection(parent=self._node_cs, name='Coronal') self.coron.transform = vist.ChainTransform(tf_coron) # Sagittal : self.sagit = ImageSection(parent=self._node_cs, name='Sagittal') self.sagit.transform = vist.ChainTransform(tf_sagit) # Set GL state : kwargs = { 'depth_test': True, 'cull_face': False, 'blend': False, 'blend_func': ('src_alpha', 'one_minus_src_alpha') } self.sagit.set_gl_state('translucent', **kwargs) self.coron.set_gl_state('translucent', **kwargs) self.axial.set_gl_state('translucent', **kwargs)
def __init__(self, view, radius, path, face_color, tube_points=16, closed=True): """ points : ndarray An array of (x, y, z) points describing the path along which the tube will be extruded. radius : float The radius of the tube. Defaults to 1.0. closed : bool Whether the tube should be closed, joining the last point to the first. Defaults to False. color : Color | ColorArray The color(s) to use when drawing the tube. The same color is applied to each vertex of the mesh surrounding each point of the line. If the input is a ColorArray, the argument will be cycled; for instance if 'red' is passed then the entire tube will be red, or if ['green', 'blue'] is passed then the points will alternate between these colours. Defaults to 'purple'. tube_points : int The number of points in the circle-approximating polygon of the tube's cross section. Defaults to 8. shading : str | None Same as for the `MeshVisual` class. Defaults to 'smooth'. vertex_colors: ndarray | None Same as for the `MeshVisual` class. face_colors: ndarray | None Same as for the `MeshVisual` class. mode : str Same as for the `MeshVisual` class. Defaults to 'triangles'. """ super(mbTube, self).__init__(radius=radius, points=path, color=face_color, tube_points=tube_points, closed=closed, parent=view) self.transform = transforms.MatrixTransform()
def add_cubes(): cm = get_colormap('hot') how_many_seg = 5 for l in range(how_many_seg): for m in range(how_many_seg): for n in range(how_many_seg): cube_size = 0.15 how_much_red = np.random.random() cube = scene.visuals.Sphere( radius=cube_size/2 , method='latitude' , color=cm[np.random.random()] ) #cube = scene.visuals.Cube((cube_size, cube_size, cube_size), #color=ColorArray((how_much_red, 0, 0, 0.8)))#, #edge_color='k') cube.transform = transforms.MatrixTransform() to_translate = 0.4 cube.transform.translate((to_translate*(l-how_many_seg//2), to_translate*(m-how_many_seg//2), to_translate*(n-how_many_seg//2))) _context.view.add(cube)
def test_convert_meshdata(self): """Test convert_meshdata function.""" from vispy.geometry import MeshData import vispy.visuals.transforms as vist # Force creation of vertices, faces and normals : self._creation() tup = (self.vertices, self.faces) # Compare (vertices + faces) Vs. MeshData : mesh1 = convert_meshdata(*tup) mesh2 = convert_meshdata(meshdata=MeshData(*tup)) assert np.array_equal(mesh1[0], mesh2[0]) assert np.array_equal(mesh1[1], mesh2[1]) assert np.array_equal(mesh1[2], mesh2[2]) # Invert normals : inv1 = convert_meshdata(*tup, invert_normals=True)[-1] assert np.array_equal(inv1, -mesh1[-1]) # Create transformation : tr = vist.MatrixTransform() tr.rotate(90, (0, 0, 1)) convert_meshdata(*tup, transform=tr)[-1]
def __init__(self, name, vol, transform=None, roi_values=None, roi_labels=None): """Init.""" ####################################################################### # CHECK DATA ####################################################################### # Name : if isinstance(name, str): self.name = name else: raise ValueError("The name variable must be a string.") # Volume : if isinstance(vol, np.ndarray) and (vol.ndim == 3): self.vol = vol else: raise ValueError("The vol variable must be 3-D array.") # Transformation : if not isinstance(transform, vist.MatrixTransform): self.transform = vist.MatrixTransform() else: self.transform = transform # Index and label : if isinstance(roi_values, np.ndarray) and isinstance( roi_labels, np.ndarray): self._is_roi = len(roi_labels) == len(roi_values) else: self._is_roi = False self.roi_values = roi_values self.roi_labels = roi_labels # Get (nx, ny, nz) and minmax : self._sh = vol.shape self._nx, self._ny, self._nz = np.array(self._sh) - 1 self._minmax = (vol.min(), vol.max()) self._clim = self._minmax
def test_affine_mapping(): t = tr.MatrixTransform() p1 = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]]) # test pure translation p2 = p1 + 5.5 t.set_mapping(p1, p2) assert np.allclose(t.map(p1)[:, :p2.shape[1]], p2) # test pure scaling p2 = p1 * 5.5 t.set_mapping(p1, p2) assert np.allclose(t.map(p1)[:, :p2.shape[1]], p2) # test scale + translate p2 = (p1 * 5.5) + 3.5 t.set_mapping(p1, p2) assert np.allclose(t.map(p1)[:, :p2.shape[1]], p2) # test SRT p2 = np.array([[10, 5, 3], [10, 15, 3], [30, 5, 3], [10, 5, 3.5]]) t.set_mapping(p1, p2) assert np.allclose(t.map(p1)[:, :p2.shape[1]], p2)
def update(self, t, crazyflies): if len(self.cfs) == 0: verts, faces, normals, nothin = io.read_mesh( os.path.join(os.path.dirname(__file__), "crazyflie2.obj.gz")) for i in range(0, len(crazyflies)): mesh = scene.visuals.Mesh(vertices=verts, shading='smooth', faces=faces, parent=self.view.scene) mesh.transform = transforms.MatrixTransform() self.cfs.append(mesh) for i in range(0, len(self.cfs)): x, y, z = crazyflies[i].position() roll, pitch, yaw = crazyflies[i].rpy() self.cfs[i].transform.reset() self.cfs[i].transform.rotate(90, (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(roll), (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(pitch), (0, 1, 0)) self.cfs[i].transform.rotate(math.degrees(yaw), (0, 0, 1)) self.cfs[i].transform.scale((0.001, 0.001, 0.001)) self.cfs[i].transform.translate((x, y, z)) self.canvas.app.process_events()
def on_timer(self, ev): millis_passed = int(100 * (self.model.t % 1)) sec_passed = int(self.model.t % 60) min_passed = int(self.model.t // 60) self.rear_wheelsL.transform.reset() self.rear_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsL.transform.translate([0.0, -self.scale*0.5*4.0]) self.rear_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsL.transform.translate([self.model.x, self.model.y]) self.rear_wheelsL.transform.translate(self.center) self.rear_wheelsR.transform.reset() self.rear_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsR.transform.translate([0.0, self.scale*0.5*4.0]) self.rear_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsR.transform.translate([self.model.x, self.model.y]) self.rear_wheelsR.transform.translate(self.center) self.front_wheelsL.transform.reset() self.front_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsL.transform.translate([self.scale*self.model.l, -self.scale*0.5*4.0]) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsL.transform.translate([self.model.x, self.model.y]) self.front_wheelsL.transform.translate(self.center) self.front_wheelsR.transform.reset() self.front_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsR.transform.translate([self.scale*self.model.l, self.scale*0.5*4.0]) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsR.transform.translate([self.model.x, self.model.y]) self.front_wheelsR.transform.translate(self.center) # Apply the necessary transformations to the vehicle_body self.vehicle_body.transform.reset() self.vehicle_body.transform.translate([0.5, 0.0]) self.vehicle_body.transform.scale((self.scale*self.model.l, self.scale, 1)) self.vehicle_body.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_body.transform.translate([self.model.x, self.model.y]) self.vehicle_body.transform.translate(self.center) self.vehicle_bodyF.transform.reset() self.vehicle_bodyF.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyF.transform.translate([self.model.l*self.scale, 0.0]) self.vehicle_bodyF.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyF.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyF.transform.translate(self.center) self.vehicle_bodyR.transform.reset() self.vehicle_bodyR.transform = transforms.MatrixTransform() self.vehicle_bodyR.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyR.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyR.transform.translate(self.center) # Update the timer with how long it's been self.text.text = '{:0>2d}:{:0>2d}.{:0>2d}'.format(min_passed, sec_passed, millis_passed) self.update() self.model.do_time_step()
def __init__(self, view, a, b, c, face_color, edge_color): super(mbCube, self).__init__((a, b, c), color=face_color, edge_color=edge_color, parent=view) self.transform = transforms.MatrixTransform()
if it is not a pure scaling transform ''' assert isinstance( M, transforms.MatrixTransform), "need MatrixTransform object" # scaling, rotation, shear happens in the top left 3x3 matrix R = np.array(M.matrix)[:3, :3] if not is_diag(R): # issue warning that it is not pure scale + translate return None # scaling information is just the diagonal return np.diag(R) if __name__ == "__main__": transform = transforms.MatrixTransform() print("after instantiation") print("scale: ", get_scale_from_MatrixTransform(transform)) print("translate: ", get_translation_from_MatrixTransform(transform)) transform.scale((99.0, 11.0, 1.1)) transform.translate((200, 100)) print("After scale and translate") print("scale: ", get_scale_from_MatrixTransform(transform)) print("translate: ", get_translation_from_MatrixTransform(transform)) transform.rotate(33.0, (0.5, 1.0, 1.0)) print("After rotate") print("scale: ", get_scale_from_MatrixTransform(transform)) print("translate: ", get_translation_from_MatrixTransform(transform))
def update(self, t, crazyflies): if len(self.cfs) == 0: verts, faces, normals, nothin = io.read_mesh(CF_MESH_PATH) for i, cf in enumerate(crazyflies): color = cf.ledRGB mesh = scene.visuals.Mesh( parent=self.view.scene, vertices=verts, faces=faces, color=color, shading="smooth", ) mesh.light_dir = (0.1, 0.1, 1.0) mesh.shininess = 0.01 mesh.ambient_light_color = [0.5] * 3 mesh.transform = transforms.MatrixTransform() self.cfs.append(mesh) self.led_color_cache.append(color) if self.ellipsoid_radii is not None and self.ellipsoids is None: sphere_mesh = geometry.create_sphere(radius=1.0) self.ellipsoids = [ scene.visuals.Mesh( parent=self.view.scene, meshdata=sphere_mesh, color=ELLIPSOID_COLOR_OK, shading="smooth", ) for _ in self.cfs ] for ell in self.ellipsoids: ell.light_dir = (0.1, 0.1, 1.0) ell.shininess = 0.0 ell.ambient_light_color = [0.5] * 3 ell.transform = transforms.MatrixTransform() positions = np.stack([cf.position() for cf in crazyflies]) for i in range(0, len(self.cfs)): x, y, z = crazyflies[i].position() roll, pitch, yaw = crazyflies[i].rpy() self.cfs[i].transform.reset() self.cfs[i].transform.rotate(-90, (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(roll), (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(pitch), (0, 1, 0)) self.cfs[i].transform.rotate(math.degrees(yaw), (0, 0, 1)) self.cfs[i].transform.scale((0.002, 0.002, -0.002)) self.cfs[i].transform.translate(positions[i]) # vispy does not do this check color = crazyflies[i].ledRGB if color != self.led_color_cache[i]: self.led_color_cache[i] = color self.cfs[i].color = color # sets dirty flag # Update graph line segments to match new Crazyflie positions. if self.graph is not None: for k, (i, j) in enumerate(self.graph_edges): self.graph_lines[2 * k, :] = positions[i] self.graph_lines[2 * k + 1, :] = positions[j] self.graph.set_data(self.graph_lines) # Update collsiion ellipsoids. if self.ellipsoids is not None: colliding = util.check_ellipsoid_collisions( positions, self.ellipsoid_radii) for i, pos in enumerate(positions): ell = self.ellipsoids[i] tf = ell.transform tf.reset() tf.scale(self.ellipsoid_radii) tf.translate(pos) new_color = ELLIPSOID_COLOR_COLLISION if colliding[ i] else ELLIPSOID_COLOR_OK if not (new_color == ell.color): # vispy Color lacks != override. ell.color = new_color self.canvas.app.process_events()
def update(self, t, crazyflies, spheres=[], obstacles=[], crumb=None): if len(self.cfs ) == 0: # add the crazyflies if they don't exist already verts, faces, normals, nothin = io.read_mesh( os.path.join(os.path.dirname(__file__), "crazyflie2.obj.gz")) for i in range(0, len(crazyflies)): mesh = scene.visuals.Mesh(vertices=verts, shading='smooth', faces=faces, parent=self.view.scene) mesh.transform = transforms.MatrixTransform() self.cfs.append(mesh) if crumb is not None: # add breadcrumb trails behind drones if requested. if len(self.crumbs) == 0 or np.linalg.norm(self.crumbs[-1] - crumb) > 0.05: # Only add them if drone is sufficiently far from the last breakcrumb. self.crumbs.append(crumb) self.markers.set_data(np.array(self.crumbs), size=5, face_color='black', edge_color='black') elif self.crumbs: self.markers.set_data(np.array([[1e10, 1e10]])) self.crumbs = [] if spheres: # sphere: (position, color) if not self.spheres: for pos, color in spheres: self.spheres.append( scene.visuals.Sphere(radius=.02, color=color, parent=self.view.scene)) self.spheres[-1].transform = transforms.STTransform( translate=pos) for i, (pos, color) in enumerate(spheres): self.spheres[i].transform.translate = pos if obstacles: # cube : (position, size) if not self.obstacles: for pos, size, _ in obstacles: self.obstacles.append( scene.visuals.Cube(size=size, color=random.choice( get_color_names()), parent=self.view.scene)) self.obstacles[-1].transform = transforms.STTransform( translate=pos) for i, (pos, size, _) in enumerate(obstacles): self.obstacles[i].transform.translate = pos # update the location of the crazyflies if they have changed for i in range(0, len(self.cfs)): x, y, z = crazyflies[i].position(t) roll, pitch, yaw = crazyflies[i].rpy(t) self.cfs[i].transform.reset() self.cfs[i].transform.rotate(90, (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(roll), (1, 0, 0)) self.cfs[i].transform.rotate(math.degrees(pitch), (0, 1, 0)) self.cfs[i].transform.rotate(math.degrees(yaw), (0, 0, 1)) self.cfs[i].transform.scale((0.001, 0.001, 0.001)) self.cfs[i].transform.translate((x, y, z)) self.canvas.app.process_events() # redraw the canvas
def __init__(self, list_of_charts, theta, omega, g, m, kp, kd, l, scale, method, control, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.model = PendulumModel(list_of_charts) self.list_of_charts = list_of_charts self.vis_length = l self._set_up_system(l=l, g=g, m=m, theta=theta, omega=omega, kp=kp, kd=kd, scale=scale, method=method, control=control, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.params = [] self.params.append( visuals.TextVisual('td', color='white', pos=[15, 80, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_1090', color='white', pos=[15, 100, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_0595', color='white', pos=[15, 120, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tr_0100', color='white', pos=[15, 140, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('tp', color='white', pos=[15, 160, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('over', color='white', pos=[15, 180, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('ts_2', color='white', pos=[15, 200, 0], anchor_x='left', anchor_y='bottom')) self.params.append( visuals.TextVisual('ts_5', color='white', pos=[15, 220, 0], anchor_x='left', anchor_y='bottom')) for param in self.params: param.font_size = 12 self.hook = visuals.BoxVisual(width=0.25, height=0.25, depth=0.25, color='grey') self.hook.transform = transforms.MatrixTransform() self.hook.transform.scale( (self.scale * self.model.l, self.scale * self.model.l, 0.0001)) self.hook.transform.translate(self.center) self.rod = visuals.BoxVisual(width=self.vis_length / 40, height=self.vis_length / 40, depth=self.vis_length, color='green') self.rod.transform = transforms.MatrixTransform() self.rod.transform.translate([0.0, self.vis_length / 2.0]) self.rod.transform.scale( (self.scale * self.model.l, self.scale * self.model.l, 0.0001)) self.rod.transform.rotate(np.rad2deg(self.model.theta), (0, 0, 1)) self.rod.transform.translate(self.center) # Append all the visuals self.visuals.append(self.rod) self.visuals.append(self.hook) self.visuals.append(self.text) for param in self.params: self.visuals.append(param)
def __init__(self, list_of_charts, theta, fi, kp, kd, l, scale, x, y, method, control, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.center = [400, 400] self.model = VehicleKinematicModel(list_of_charts) self.list_of_charts = list_of_charts self._set_up_system( l=l, theta=theta, fi=fi, x=x, y=y, kp=kp, kd=kd, scale=scale, method=method, control=control, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size ) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.rear_wheelsL = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='yellow') self.rear_wheelsL.transform = transforms.MatrixTransform() self.rear_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsL.transform.translate([0.0, -self.scale*0.5*4.0]) self.rear_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsL.transform.translate([self.model.x, self.model.y]) self.rear_wheelsL.transform.translate(self.center) self.rear_wheelsR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='yellow') self.rear_wheelsR.transform = transforms.MatrixTransform() self.rear_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.rear_wheelsR.transform.translate([0.0, self.scale*0.5*4.0]) self.rear_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.rear_wheelsR.transform.translate([self.model.x, self.model.y]) self.rear_wheelsR.transform.translate(self.center) self.front_wheelsL = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='pink') self.front_wheelsL.transform = transforms.MatrixTransform() self.front_wheelsL.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsL.transform.translate([self.scale*l, -self.scale*0.5*4.0]) self.front_wheelsL.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsL.transform.translate([self.model.x, self.model.y]) self.front_wheelsL.transform.translate(self.center) self.front_wheelsR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='pink') self.front_wheelsR.transform = transforms.MatrixTransform() self.front_wheelsR.transform.scale((self.scale*2.0, self.scale*0.5, 1)) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.fi), (0, 0, 1)) self.front_wheelsR.transform.translate([self.scale*l, self.scale*0.5*4.0]) self.front_wheelsR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.front_wheelsR.transform.translate([self.model.x, self.model.y]) self.front_wheelsR.transform.translate(self.center) self.vehicle_body = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='green') self.vehicle_body.transform = transforms.MatrixTransform() self.vehicle_body.transform.translate([0.5, 0.0]) self.vehicle_body.transform.scale((self.scale*self.model.l, self.scale, 1)) self.vehicle_body.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_body.transform.translate([self.model.x, self.model.y]) self.vehicle_body.transform.translate(self.center) self.vehicle_bodyF = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='red') self.vehicle_bodyF.transform = transforms.MatrixTransform() self.vehicle_bodyF.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyF.transform.translate([l*self.scale, 0.0]) self.vehicle_bodyF.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyF.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyF.transform.translate(self.center) self.vehicle_bodyR = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='blue') self.vehicle_bodyR.transform = transforms.MatrixTransform() self.vehicle_bodyR.transform.scale((self.scale*0.25, self.scale*4.0, 1)) self.vehicle_bodyR.transform.rotate(np.rad2deg(-self.model.theta), (0, 0, 1)) self.vehicle_bodyR.transform.translate([self.model.x, self.model.y]) self.vehicle_bodyR.transform.translate(self.center) # Append all the visuals self.visuals.append(self.vehicle_body) self.visuals.append(self.vehicle_bodyF) self.visuals.append(self.vehicle_bodyR) self.visuals.append(self.rear_wheelsL) self.visuals.append(self.rear_wheelsR) self.visuals.append(self.front_wheelsL) self.visuals.append(self.front_wheelsR) self.visuals.append(self.text)
def __init__(self, d1=None, d2=None, little_m=None, big_m=None, spring_k1=None, spring_k2=None, b=None, x=None, x_dot=None, theta=None, theta_dot=None, px_len=None, scale=None, pivot=False, method='Euler', dt=None, font_size=None): """ Main VisPy Canvas for simulation of physical system. Parameters ---------- d1 : float Length of rod (in meters) from pivot to upper spring. d2 : float Length of rod (in meters) from pivot to lower spring. little_m : float Mass of attached cube (in kilograms). big_m : float Mass of rod (in kilograms). spring_k1 : float Spring constant of lower spring (in N/m). spring_k2 : float Spring constant of upper spring (in N/m). b : float Coefficient of quadratic sliding friction (in kg/m). x : float Initial x-position of mass (in m). x_dot : float Initial x-velocity of mass (in m/s). theta : float Initial angle of rod, with respect to vertical (in radians). theta_dot : float Initial angular velocity of rod (in rad/s). px_len : int Length of the rod, in pixels. scale : int Scaling factor to change size of elements. pivot : bool Switch for showing/hiding pivot point. method : str Method to use for updating. dt : float Time step for simulation. font_size : float Size of font for text elements, in points. Notes ----- As of right now, the only supported methods are "euler" or "runge-kutta". These correspond to an Euler method or an order 3 Runge-Kutta method for updating x, theta, x dot, and theta dot. """ app.Canvas.__init__(self, title='Wiggly Bar', size=(800, 800)) # Some initialization constants that won't change self.standard_length = 0.97 + 0.55 self.center = np.asarray((500, 450)) self.visuals = [] self._set_up_system(d1=d1, d2=d2, little_m=little_m, big_m=big_m, spring_k1=spring_k1, spring_k2=spring_k2, b=b, x=x, x_dot=x_dot, theta=theta, theta_dot=theta_dot, px_len=px_len, scale=scale, pivot=pivot, method=method, dt=dt, font_size=font_size) piv_x_y_px = np.asarray( (self.pivot_loc_px * np.sin(self.theta), -1 * self.pivot_loc_px * (np.cos(self.theta)))) # Make the spring points points = make_spring(height=self.px_len / 4, radius=self.px_len / 24) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[50, 250, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size # Let's put in more text so we know what method is being used to # update this self.method_text = visuals.TextVisual( 'Method: {}'.format(self.method), color='white', pos=[50, 250 + 2 / 3 * font_size, 0], anchor_x='left', anchor_y='top') self.method_text.font_size = 2 / 3 * self.font_size # Get the pivoting bar ready self.rod = visuals.BoxVisual(width=self.px_len / 40, height=self.px_len / 40, depth=self.px_len, color='white') self.rod.transform = transforms.MatrixTransform() self.rod.transform.scale( (self.scale, self.scale * self.rod_scale, 0.0001)) self.rod.transform.rotate(np.rad2deg(self.theta), (0, 0, 1)) self.rod.transform.translate(self.center - piv_x_y_px) # Show the pivot point (optional) pivot_center = (self.center[0], self.center[1], -self.px_len / 75) self.center_point = visuals.SphereVisual(radius=self.px_len / 75, color='red') self.center_point.transform = transforms.MatrixTransform() self.center_point.transform.scale((self.scale, self.scale, 0.0001)) self.center_point.transform.translate(pivot_center) # Get the upper spring ready. self.spring_2 = visuals.TubeVisual(points, radius=self.px_len / 100, color=(0.5, 0.5, 1, 1)) self.spring_2.transform = transforms.MatrixTransform() self.spring_2.transform.rotate(90, (0, 1, 0)) self.spring_2.transform.scale((self.scale, self.scale, 0.0001)) self.spring_2.transform.translate(self.center + self.s2_loc) # Get the lower spring ready. self.spring_1 = visuals.TubeVisual(points, radius=self.px_len / 100, color=(0.5, 0.5, 1, 1)) self.spring_1.transform = transforms.MatrixTransform() self.spring_1.transform.rotate(90, (0, 1, 0)) self.spring_1.transform.scale( (self.scale * (1.0 - (self.x * self.px_per_m) / (self.scale * self.px_len / 2)), self.scale, 0.0001)) self.spring_1.transform.translate(self.center + self.s1_loc) # Finally, prepare the mass that is being moved self.mass = visuals.BoxVisual(width=self.px_len / 4, height=self.px_len / 8, depth=self.px_len / 4, color='white') self.mass.transform = transforms.MatrixTransform() self.mass.transform.scale((self.scale, self.scale, 0.0001)) self.mass.transform.translate(self.center + self.mass_loc) # Append all the visuals self.visuals.append(self.center_point) self.visuals.append(self.rod) self.visuals.append(self.spring_2) self.visuals.append(self.spring_1) self.visuals.append(self.mass) self.visuals.append(self.text) self.visuals.append(self.method_text) # Set up a timer to update the image and give a real-time rendering self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def __init__(self, list_of_charts, theta, omega, g, M, m, kp, kd, A, f, l, scale, x, V, method, control, noise, save_charts, dt, tmax, font_size): VisualModel.__init__(self) self.model = CranePhysicalModel(list_of_charts) self.list_of_charts = list_of_charts self._set_up_system(l=l, g=g, M=M, m=m, theta=theta, omega=omega, x=x, V=V, kp=kp, kd=kd, A=A, f=f, scale=scale, method=method, control=control, noise=noise, save_charts=save_charts, dt=dt, tmax=tmax, font_size=font_size) # Put up a text visual to display time info self.font_size = 24. if font_size is None else font_size self.text = visuals.TextVisual('0:00.00', color='white', pos=[15, 50, 0], anchor_x='left', anchor_y='bottom') self.text.font_size = self.font_size self.hook_length = self.scale * 30.0 self.hook_height = self.scale * 0.2 self.hook = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='grey') self.hook.transform = transforms.MatrixTransform() self.hook.transform.scale((self.hook_length, self.hook_height, 0.001)) self.hook.transform.translate( [self.hook_length / 2.016 + self.scale * self.model.x, 0.0]) self.hook.transform.translate(self.center) self.rod_width = self.scale * self.model.l / 20.0 self.rod = visuals.BoxVisual(width=1.0, height=1.0, depth=1.0, color='green') self.rod.transform = transforms.MatrixTransform() self.rod.transform.scale( (self.rod_width, self.scale * self.model.l, 0.0001)) self.rod.transform.translate([0.0, self.scale * self.model.l / 2.0]) self.rod.transform.rotate(np.rad2deg(self.model.theta), (0, 0, 1)) self.rod.transform.translate([self.scale * self.model.x, 0.0]) self.rod.transform.translate(self.center) # Append all the visuals self.visuals.append(self.rod) self.visuals.append(self.hook) self.visuals.append(self.text)