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
