def update_shape(self, view): wvl = self.opt_model['optical_spec']['wvls'].central_wvl self.wvl = wvl rayset = trace_boundary_rays_at_field(self.opt_model, self.fld, wvl, use_named_tuples=True) self.rayset = boundary_ray_dict(self.opt_model, rayset) # If the object distance (tfrms[0][1][2]) is greater than the # start_offset, then modify rayset start to match start_offset. # Remember object transformation for resetting at the end. seq_model = self.opt_model.seq_model tfrms = seq_model.gbl_tfrms tfrtm0 = tfrms[0] start_bundle = [r.ray[0] for r in self.rayset.values()] ray_list = [r for r in self.rayset.values()] if abs(tfrtm0[1][2]) > self.start_offset: rot, t = setup_shift_of_ray_bundle(seq_model, self.start_offset) tfrms[0] = (rot, t) shift_start_of_ray_bundle(start_bundle, ray_list, rot, t) try: if view.do_draw_beams: poly, bbox = self.render_shape(self.rayset, start_bundle, tfrms) p = view.create_polygon(poly, fill_color=lo_rgb['rayfan_fill']) self.handles['shape'] = GUIHandle(p, bbox) if view.do_draw_edge_rays: cr = self.render_ray(self.rayset['00'].ray, start_bundle[0], tfrms) upr = self.render_ray(self.rayset['+Y'].ray, start_bundle[3], tfrms) lwr = self.render_ray(self.rayset['-Y'].ray, start_bundle[4], tfrms) kwargs = { 'linewidth': lo_lw['line'], 'color': lo_rgb['ray'], 'hilite_linewidth': lo_lw['hilite'], 'hilite': lo_rgb['ray'], } cr_poly = view.create_polyline(cr, **kwargs) self.handles['00'] = GUIHandle(cr_poly, bbox_from_poly(cr)) upr_poly = view.create_polyline(upr, **kwargs) self.handles['+Y'] = GUIHandle(upr_poly, bbox_from_poly(upr)) lwr_poly = view.create_polyline(lwr, **kwargs) self.handles['-Y'] = GUIHandle(lwr_poly, bbox_from_poly(lwr)) finally: tfrms[0] = tfrtm0 return self.handles
def update_data(self, **kwargs): self.artists = [] concat_bbox = [] layout = self.layout self.ele_shapes = layout.create_element_model(self) self.ele_bbox = self.update_patches(self.ele_shapes) concat_bbox.append(self.ele_bbox) if self.do_draw_rays: sl_so = layout.system_length(self.ele_bbox, offset_factor=self.offset_factor) system_length, start_offset = sl_so self.ray_shapes = layout.create_ray_model(self, start_offset) self.ray_bbox = self.update_patches(self.ray_shapes) concat_bbox.append(self.ray_bbox) if self.do_paraxial_layout: self.parax_shapes = layout.create_paraxial_layout(self) self.parax_bbox = self.update_patches(self.parax_shapes) concat_bbox.append(self.parax_bbox) sys_bbox = np.concatenate(concat_bbox) self.sys_bbox = bbox_from_poly(sys_bbox) return self
def update_data(self, fig): parax_model = self.opt_model.parax_model if fig.build == 'update': # just a change in node positions self.shape = self.render_shape() else: # number of nodes have changed, rebuild everything if fig.build == 'full_rebuild': # change from another non-parax_model source, # rebuild parax_model parax_model.build_lens() self.shape = self.render_shape() self.node_list = [] for i in range(len(parax_model.sys)): self.node_list.append(DiagramNode(self, i)) self.edge_list = [] for i in range(len(parax_model.sys)-1): self.edge_list.append(DiagramEdge(self, i)) concat_bbox = [] self.node_bbox = fig.update_patches(self.node_list) concat_bbox.append(self.node_bbox) self.edge_bbox = fig.update_patches(self.edge_list) concat_bbox.append(self.edge_bbox) # dgm_bbox = self.update_patches([self.diagram]) dgm_bbox = np.concatenate(concat_bbox) sys_bbox = bbox_from_poly(dgm_bbox) return sys_bbox
def update_data(self, **kwargs): self.artists = [] concat_bbox = [] layout = self.layout self.ele_shapes = layout.create_element_entities(self) self.ele_bbox = self.update_patches(self.ele_shapes) concat_bbox.append(self.ele_bbox) if self.do_draw_beams or self.do_draw_edge_rays or self.do_draw_ray_fans: sl_so = layout.system_length(self.ele_bbox, offset_factor=self.offset_factor) system_length, start_offset = sl_so if self.do_draw_beams or self.do_draw_edge_rays: self.ray_shapes = layout.create_ray_entities(self, start_offset) self.ray_bbox = self.update_patches(self.ray_shapes) concat_bbox.append(self.ray_bbox) if self.do_draw_ray_fans: self.rayfan_shapes = layout.create_ray_fan_entities( self, start_offset, num_rays=self.num_rays_in_fan) self.rayfan_bbox = self.update_patches(self.rayfan_shapes) concat_bbox.append(self.rayfan_bbox) if self.do_paraxial_layout: self.parax_shapes = layout.create_paraxial_ray_entities(self) self.parax_bbox = self.update_patches(self.parax_shapes) concat_bbox.append(self.parax_bbox) sys_bbox = np.concatenate(concat_bbox) self.sys_bbox = bbox_from_poly(sys_bbox) return self
def update_shape(self, view): rndr_clr = [254, 197, 254, 64] # magenta, 25% wvl = self.opt_model.optical_spec.spectral_region.central_wvl self.wvl = wvl rayset = trace_boundary_rays_at_field(self.opt_model, self.fld, wvl, use_named_tuples=True) self.rayset = boundary_ray_dict(self.opt_model, rayset) # If the object distance (tfrms[0][1][2]) is greater than the # start_offset, then modify rayset start to match start_offset. # Remember object transformation for resetting at the end. seq_model = self.opt_model.seq_model tfrms = seq_model.gbl_tfrms tfrtm0 = tfrms[0] start_bundle = [r.ray[0] for r in self.rayset.values()] if abs(tfrtm0[1][2]) > self.start_offset: rot, t = setup_shift_of_ray_bundle(seq_model, self.start_offset) tfrms[0] = (rot, t) shift_start_of_ray_bundle(start_bundle, self.rayset.values(), rot, t) try: poly, bbox = self.render_shape(self.rayset, start_bundle, tfrms) cr = self.render_ray(self.rayset['00'].ray, start_bundle[0], tfrms) upr = self.render_ray(self.rayset['+Y'].ray, start_bundle[3], tfrms) lwr = self.render_ray(self.rayset['-Y'].ray, start_bundle[4], tfrms) finally: tfrms[0] = tfrtm0 p = view.create_polygon(poly, fill_color=rndr_clr) self.handles['shape'] = GUIHandle(p, bbox) cr_poly = view.create_polyline(cr) self.handles['00'] = GUIHandle(cr_poly, bbox_from_poly(cr)) upr_poly = view.create_polyline(upr) self.handles['+Y'] = GUIHandle(upr_poly, bbox_from_poly(upr)) lwr_poly = view.create_polyline(lwr) self.handles['-Y'] = GUIHandle(lwr_poly, bbox_from_poly(lwr)) return self.handles
def update_patches(self, shapes): bbox_list = [] for shape in shapes: poly, bbox = shape[0](shape[1]) self.artists.append(poly) if len(bbox_list) == 0: bbox_list = bbox else: bbox_list = np.vstack((bbox_list, bbox)) bbox = util.bbox_from_poly(bbox_list) return bbox
def render_shape(self, rayset, start_bundle, tfrms): poly1 = [] transform_ray_seg(poly1, start_bundle[3], tfrms[0]) for i, r in enumerate(rayset['+Y'].ray[1:], 1): transform_ray_seg(poly1, r, tfrms[i]) poly2 = [] transform_ray_seg(poly2, start_bundle[4], tfrms[0]) for i, r in enumerate(rayset['-Y'].ray[1:], 1): transform_ray_seg(poly2, r, tfrms[i]) poly2.reverse() poly1.extend(poly2) bbox = bbox_from_poly(poly1) return poly1, bbox
def update_shape(self, view): seq_model = self.opt_model.seq_model tfrms = seq_model.gbl_tfrms ray_poly = self.render_ray(self.ray, tfrms) priority = 3 rp = view.create_polyline(ray_poly, color=self.color, linewidth=1, hilite=self.color, zorder=priority) self.handles['shape'] = GUIHandle(rp, bbox_from_poly(ray_poly)) return self.handles
def update_data(self): self.artists = [] self.ele_shapes = self.create_element_model(self.opt_model.ele_model) self.ele_bbox = self.update_patches(self.ele_shapes) if self.do_draw_rays: offset = self.offset_factor self.ray_shapes = self.create_ray_model(offset_factor=offset) self.ray_bbox = self.update_patches(self.ray_shapes) concat_bbox = np.concatenate((self.ele_bbox, self.ray_bbox)) self.sys_bbox = util.bbox_from_poly(concat_bbox) else: self.sys_bbox = self.ele_bbox return self
def update_patches(self, shapes): """ loop over the input shapes, fetching their current geometry and attaching it to the corresponding ``Artist`` """ bbox_list = [] for shape in shapes: handles = shape.update_shape(self) for key, gui_handle in handles.items(): poly, bbox = gui_handle # add shape and handle key as attribute on artist poly.shape = (shape, key) self.artists.append(poly) if len(bbox_list) == 0: bbox_list = bbox else: bbox_list = np.vstack((bbox_list, bbox)) bbox = util.bbox_from_poly(bbox_list) return bbox
def update_data(self, fig, **kwargs): parax_model = self.parax_model self.shape = self.render_shape() self.shape_bbox = bbox_from_poly(self.shape) build = kwargs.get('build', fig.build) if build == 'update': # just a change in node positions - handled above # self.shape = self.render_shape() pass else: # number of nodes have changed, rebuild everything if build == 'full_rebuild': # change from another non-parax_model source, # rebuild parax_model parax_model.build_lens() self.node_list = [] for i in range(len(parax_model.sys)): self.node_list.append(DiagramNode(self, i)) self.edge_list = [] for i in range(len(parax_model.sys) - 1): self.edge_list.append(DiagramEdge(self, i)) self.object_shift = ConjugateLine(self, 'object_image') if self.opt_model.seq_model.stop_surface is None: # stop shift conjugate line is only editable for floating stop self.stop_shift = ConjugateLine(self, 'stop') if self.do_barrel_constraint: self.barrel_constraint = BarrelConstraint(self) self.node_bbox = fig.update_patches(self.node_list) self.edge_bbox = fig.update_patches(self.edge_list) self.object_shift_bbox = fig.update_patches([self.object_shift]) if self.opt_model.seq_model.stop_surface is None: self.stop_shift_bbox = fig.update_patches([self.stop_shift]) if self.do_barrel_constraint: self.barrel_bbox = fig.update_patches([self.barrel_constraint]) return self.shape_bbox
def update_shape(self, view): n_color = rgb2mpl([138, 43, 226]) # blueviolet sys = self.diagram.opt_model.parax_model.sys shape = self.diagram.shape self.handles['shape'] = shape[self.node], 'vertex', {'linestyle': '', 'marker': 's', 'picker': 6, 'color': n_color, 'hilite': 'red', 'zorder': 3.} # define the "constant spacing" or "slide" constraint slide_pts = compute_slide_line(shape, self.node, sys[self.node][rmd]) if slide_pts is not None: seg = [*slide_pts] f_color = rgb2mpl([138, 43, 226, 63]) # blueviolet h_color = rgb2mpl([138, 43, 226, 255]) # blueviolet self.handles['slide'] = seg, 'polyline', {'linestyle': ':', 'picker': 6, 'color': f_color, 'hilite': h_color, 'zorder': 2.5} gui_handles = {} for key, graphics_handle in self.handles.items(): poly_data, poly_type, kwargs = graphics_handle poly = np.array(poly_data) if poly_type == 'vertex': p = view.create_vertex(poly, **kwargs) elif poly_type == 'polyline': p = view.create_polyline(poly, **kwargs) elif poly_type == 'polygon': p = view.create_polygon(poly, self.render_color(), **kwargs) else: break if len(poly.shape) > 1: bbox = bbox_from_poly(poly) else: x = poly[0] y = poly[1] bbox = np.array([[x, y], [x, y]]) gui_handles[key] = GUIHandle(p, bbox) return gui_handles
def update_shape(self, view): self.ray_fan.update_data() fan = self.ray_fan.fan_pkg[0] # Remember object transformation for resetting at the end. seq_model = self.opt_model.seq_model tfrms = seq_model.gbl_tfrms tfrtm0 = tfrms[0] start_bundle = [] ray_list = [] for ray_item in fan: ray_pkg = retrieve_ray(ray_item) ray = ray_pkg[0] start_bundle.append(ray[0]) ray_list.append(ray_pkg) # If the object distance (tfrms[0][1][2]) is greater than the # start_offset, then modify rayset start to match start_offset. if abs(tfrtm0[1][2]) > self.start_offset: rot, t = setup_shift_of_ray_bundle(seq_model, self.start_offset) tfrms[0] = (rot, t) cr_index = len(ray_list)//2 shift_start_of_ray_bundle(start_bundle, ray_list, rot, t, cr_indx=cr_index) kwargs = { 'linewidth': lo_lw['line'], 'color': lo_rgb['ray'], 'hilite_linewidth': lo_lw['hilite'], 'hilite': lo_rgb['ray'], } for i, rs in enumerate(zip(ray_list, start_bundle)): ray_pkg, start_seg = rs global_ray = self.render_ray(ray_pkg, start_seg, tfrms) ray_poly = view.create_polyline(global_ray, **kwargs) self.handles[i] = GUIHandle(ray_poly, bbox_from_poly(global_ray)) tfrms[0] = tfrtm0 return self.handles
def update_shape(self, view): seq_model = self.opt_model.seq_model tfrms = seq_model.gbl_tfrms ray_poly = self.render_ray(self.ray, tfrms) hilite_kwargs = { 'color': self.color, 'linewidth': lo_lw['hilite'], 'linestyle': '-' } priority = 3 rp = view.create_polyline(ray_poly, color=self.color, linewidth=lo_lw['line'], hilite=hilite_kwargs, zorder=priority) self.handles['shape'] = GUIHandle(rp, bbox_from_poly(ray_poly)) return self.handles
def create_patches(self, handles): gui_handles = {} for key, graphics_handle in handles.items(): poly_data, poly_type, kwargs = graphics_handle poly = np.array(poly_data) if poly_type == 'vertex': p = self.create_vertex(poly, **kwargs) elif poly_type == 'polyline': p = self.create_polyline(poly, **kwargs) elif poly_type == 'polygon': p = self.create_polygon(poly, **kwargs) else: break if len(poly.shape) > 1: bbox = util.bbox_from_poly(poly) else: x = poly[0] y = poly[1] bbox = np.array([[x, y], [x, y]]) gui_handles[key] = util.GUIHandle(p, bbox) return gui_handles
def update_shape(self, view): shape = self.diagram.shape edge_poly = shape[self.node:self.node+2] self.handles['shape'] = edge_poly, 'polyline', {'picker': 6, 'hilite': 'red', 'zorder': 2.} area_poly = [[0, 0]] area_poly.extend(edge_poly) fill_color = self.render_color() self.handles['area'] = area_poly, 'polygon', {'fill_color': fill_color, 'zorder': 1.} gui_handles = {} for key, graphics_handle in self.handles.items(): poly_data, poly_type, kwargs = graphics_handle poly = np.array(poly_data) if poly_type == 'polygon': p = view.create_polygon(poly, self.render_color(), **kwargs) elif poly_type == 'polyline': p = view.create_polyline(poly, **kwargs) else: break gui_handles[key] = GUIHandle(p, bbox_from_poly(poly)) return gui_handles