class singleFloat: def __init__(self, parent, parameter): self.parent = parent self.HorizontalOneParam = wx.BoxSizer(wx.HORIZONTAL) self.parameter = parameter paramName = self.parameter.getName() paramType = self.parameter.getType() paramUnit = self.parameter.getUnit() self.parNameLabel = wx.Button(parent.PNL_PARAM_EDIT, label=(paramName + '\n in ' + paramUnit)) self.parValueCtrl = FloatSpin(parent.PNL_PARAM_EDIT) # setup the limits and value for the float control [upperLimit, lowerLimit, allowedList] = self.parameter.getLimits() self.parValueCtrl.SetRange(lowerLimit, upperLimit) self.parValueCtrl.SetFormat(fmt='%e') self.parValueCtrl.SetDigits(digits=3) paramValue = self.parameter.getValue() if not paramValue == None: self.parValueCtrl.SetValue(paramValue) try: increment = (upperLimit - lowerLimit) / 10.0 except: increment = 1 self.parValueCtrl.SetIncrement(increment) # setup the limits and value for the float control if there is list of allowed values if not allowedList == None: self.parValueCtrl.Destroy() self.parValueCtrl = wx.Choice(parent.PNL_PARAM_EDIT) for value in allowedList: item = ('%8.3e' % value) self.parValueCtrl.Append(item) paramValue = self.parameter.getValue() paramValueItem = ('%8.3e' % paramValue) #print paramValueItem if not paramValue == None: idXDefault = self.parValueCtrl.FindString(paramValueItem) self.parValueCtrl.Select(idXDefault) else: self.parValueCtrl.Select(0) #self.parTypeLabel = wx.StaticText(parent.PNL_PARAM_EDIT, label=paramType[0]) #self.HorizontalOneParam.Add(self.parNameLabel, 0, wx.ALL, 5) self.HorizontalOneParam.Add( wx.StaticLine(parent.PNL_PARAM_EDIT, style=wx.LI_VERTICAL), 0, wx.ALL | wx.EXPAND, 5) self.HorizontalOneParam.Add(self.parValueCtrl, 1, wx.ALL | wx.EXPAND, 5) #self.HorizontalOneParam.Add(self.parTypeLabel,0, wx.ALL, 5) parent.paramVSizer.Add(self.parNameLabel, 0, wx.ALIGN_LEFT) parent.paramVSizer.Add(self.HorizontalOneParam, 0, wx.ALIGN_LEFT) # binding events parent.Bind(wx.EVT_BUTTON, self.OnDescribeBTN, source=self.parNameLabel) # decire if it is an choice or it is FloatSpin try: self.parValueCtrl.GetSelection() parent.Bind(wx.EVT_CHOICE, self.OnEditParam, source=self.parValueCtrl) except: self.parValueCtrl.Bind(EVT_FLOATSPIN, self.OnEditParam, source=self.parValueCtrl) return def OnEditParam(self, event): """ Update the given parameter according to control """ floatValue = 'No value found' try: value = event.GetString() floatValue = float(value) except: floatValue = self.parValueCtrl.GetValue() pass #print floatValue self.parameter.setValue(floatValue) acutalValue = self.parameter.getValue() try: self.parValueCtrl.SetValue(acutalValue) except: pass self.parent._update_description_box(( 'Parameter "%(name)s" updated to %(value)s (%(unit)s)' % \ {'name':self.parameter.getName(), 'value':str(acutalValue), 'unit':self.parameter.getUnit() })) return def OnDescribeBTN(self, event): """ Gives hint about the parameter """ parDescribe = self.parameter.getDescription() self.parent._update_description_box(parDescribe)
class KaptonSettingsPanel(wx.Panel): def __init__(self, *args, **kwds): super(KaptonSettingsPanel, self).__init__(*args, **kwds) # self.phil_params = args[0].phil_params from wx.lib.agw.floatspin import EVT_FLOATSPIN, FloatSpin # Needed to draw and delete overlays self._pyslip = self.GetParent().GetParent().pyslip sizer = wx.BoxSizer(wx.VERTICAL) self.SetSizer(sizer) # Number of decimal digits for distances. self.digits = 4 # Kapton tape controls and params from phil self._xtal_height_mm = 0.035 # LN84 shift 2 self._tape_thickness_mm = 0.05 # LN84 kapton tape self._tape_half_width_mm = 3.175 / 4. # LN84 kapton tape self._tape_angle_deg = 178.8 - 180.0 # LN84 shift 2 tape drive setup self._center = [0, 0] self.frame = self.GetParent().GetParent() self.detector = self._pyslip.tiles.raw_image.get_detector() self.panels = [p for p in self.detector] self.beam = self._pyslip.tiles.raw_image.get_beam() self.wavelength_ang = self.beam.get_wavelength() self.pixels_size_mm = [p.get_pixel_size()[0] for p in self.panels] self.distance = [p.get_directed_distance() for p in self.panels] # determine beam center and detector limits in pixels # data reads slow,fast but the dxtbx objects are organized fast,slow -- label explicitly self.panel_size = [p.get_image_size() for p in self.panels] #self.size_fast, self.size_slow = self.detector[0].get_image_size() origin = [p.get_parent_origin()[:2] for p in self.panels] #orig_fast, orig_slow = self.detector[0].get_parent_origin()[:2] #self.min_px=[map(int,self.panels[ii].millimeter_to_pixel(ori)) for ii,ori in enumerate(origin)] self.min_px = [[ int(x) for x in self.panels[ii].millimeter_to_pixel(ori) ] for ii, ori in enumerate(origin)] #self.fast_min, self.slow_min = map(int, self.detector[0].millimeter_to_pixel((orig_fast, orig_slow))) self.max_px = [(self.panel_size[ii][0] + min_px[0] - 1, self.panel_size[ii][1] + min_px[1] - 1) for ii, min_px in enumerate(self.min_px)] #self.fast_max, self.slow_max = map(lambda i: i-1, # (self.size_fast + self.fast_min, self.size_slow + self.slow_min)) self.s0 = [ map(int, p.get_beam_centre_px(self.beam.get_s0())) for p in self.panels ] #self.s0_fast, self.s0_slow = map(int, self.detector[0].get_beam_centre_px(self.beam.get_s0())) panel_id, beam_pixel_fast, beam_pixel_slow = self.frame.get_beam_center_px( ) if len(self.detector) > 1: beam_pixel_slow, beam_pixel_fast = self.frame.pyslip.tiles.flex_image.tile_readout_to_picture( panel_id, beam_pixel_slow - 0.5, beam_pixel_fast - 0.5) self.center_lon_lat = self._pyslip.tiles.picture_fast_slow_to_map_relative( beam_pixel_fast + self._center[0], beam_pixel_slow + self._center[1]) #self.center_lon_lat = self._pyslip.tiles.picture_fast_slow_to_map_relative(self.s0_fast, self.s0_slow) self._absorption = None self._kapton_control_names = [ "xtal_height_ctrl", "tape_thickness_ctrl", "tape_width_ctrl", "tape_angle_ctrl", "show_shadow_button", "show_contours_button", "show_edge_max_button", "save_params" ] box = wx.BoxSizer(wx.HORIZONTAL) self.height = FloatSpin(self, digits=self.digits, name=self._kapton_control_names[0], value=self._xtal_height_mm) self.height.SetIncrement(0.005) self.height.SetRange(0.005, None) box.Add(self.height, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) box.Add(wx.StaticText(self, label="Crystal height (mm)"), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(EVT_FLOATSPIN, self.OnSpinHeight, self.height) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.thickness = FloatSpin(self, digits=self.digits, name=self._kapton_control_names[1], value=self._tape_thickness_mm) self.thickness.SetIncrement(0.001) self.thickness.SetRange(0.001, None) box.Add(self.thickness, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) box.Add(wx.StaticText(self, label="Kapton tape thickness (mm)"), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(EVT_FLOATSPIN, self.OnSpinThickness, self.thickness) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.width = FloatSpin(self, digits=self.digits, name=self._kapton_control_names[2], value=self._tape_half_width_mm) self.width.SetIncrement(0.005) self.width.SetRange(0.005, None) box.Add(self.width, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) box.Add(wx.StaticText(self, label="Kapton tape half width (mm)"), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(EVT_FLOATSPIN, self.OnSpinWidth, self.width) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.angle = FloatSpin(self, digits=self.digits, name=self._kapton_control_names[3], value=self._tape_angle_deg) self.angle.SetIncrement(0.05) self.angle.SetRange(-360, 360) box.Add(self.angle, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) box.Add( wx.StaticText( self, label= "Kapton tape counterclockwise rotation from vertical (deg)"), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(EVT_FLOATSPIN, self.OnSpinAngle, self.angle) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.show_shadow = wx.Button(self, name=self._kapton_control_names[4], label="show kapton absorption as shadow") box.Add(self.show_shadow, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(wx.EVT_BUTTON, self.OnShowShadow, self.show_shadow) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.show_contours = wx.Button( self, name=self._kapton_control_names[5], label="show kapton absorption as contours") box.Add(self.show_contours, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(wx.EVT_BUTTON, self.OnShowContours, self.show_contours) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.show_edge_max = wx.Button( self, name=self._kapton_control_names[6], label="show kapton absorption edge and max") box.Add(self.show_edge_max, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(wx.EVT_BUTTON, self.OnShowEdgeMax, self.show_edge_max) sizer.Add(box) box = wx.BoxSizer(wx.HORIZONTAL) self.save_phil = wx.Button(self, name=self._kapton_control_names[7], label="save params and go to next image") box.Add(self.save_phil, 0, wx.RIGHT | wx.TOP | wx.BOTTOM | wx.ALIGN_CENTER_VERTICAL, 5) self.Bind(wx.EVT_BUTTON, self.OnSavePhil, self.save_phil) sizer.Add(box) def update_absorption(self): self._absorption = KaptonTape_2019(self._xtal_height_mm, self._tape_thickness_mm, self._tape_half_width_mm, self._tape_angle_deg, wavelength_ang=self.wavelength_ang) def __del__(self): if (hasattr(self, "_shadow_layer") and self._shadow_layer is not None): self._pyslip.DeleteLayer(self._shadow_layer) if (hasattr(self, "_contours_layer") and self._contours_layer is not None): self._pyslip.DeleteLayer(self._contours_layer) if (hasattr(self, "_edge_max_layer") and self._edge_max_layer is not None): self._pyslip.DeleteLayer(self._edge_max_layer) def OnSpinHeight(self, event): obj = event.EventObject name = obj.GetName() self._xtal_height_mm = obj.GetValue() self.UpdateAbsorptionData() def OnSpinThickness(self, event): obj = event.EventObject name = obj.GetName() self._tape_thickness_mm = obj.GetValue() self.UpdateAbsorptionData() def OnSpinWidth(self, event): obj = event.EventObject name = obj.GetName() self._tape_half_width_mm = obj.GetValue() self.UpdateAbsorptionData() def OnSpinAngle(self, event): obj = event.EventObject name = obj.GetName() self._tape_angle_deg = obj.GetValue() self.UpdateAbsorptionData() def OnSpin(self, event): self.UpdateAbsorptionData() def OnShowShadow(self, event): if (hasattr(self, "_shadow_layer") and self._shadow_layer is not None): self._pyslip.DeleteLayer(self._shadow_layer) self._shadow_layer = None else: self.DrawShadow() def OnShowContours(self, event): if (hasattr(self, "_contours_layer") and self._contours_layer is not None): self._pyslip.DeleteLayer(self._contours_layer) self._contours_layer = None else: self.DrawContours() def OnShowEdgeMax(self, event): if (hasattr(self, "_edge_max_layer") and self._edge_max_layer is not None): self._pyslip.DeleteLayer(self._edge_max_layer) self._edge_max_layer = None else: self.DrawEdgeMax() def OnSavePhil(self, event): import os if not (hasattr(self, "_phil_destination_dir") and self._phil_destination_dir is not None): self._run = os.path.basename( self.frame._img._raw.path).split(".pickle")[0].split("-")[-1] name = "Kapton_correction_%s.phil" % self._run dialog = wx.FileDialog( self, defaultDir='', defaultFile=name, message="Choose Kapton parameter snippet destination", style=wx.FD_SAVE, wildcard="*") if dialog.ShowModal() == wx.ID_OK: dest_path = dialog.GetPath() if os.path.isdir(dest_path): self._phil_destination_dir = dest_path self._phil_destination_path = os.path.join( self._phil_destination_dir, name) else: self._phil_destination_dir = os.path.dirname(dest_path) self._phil_destination_path = dest_path else: prev_run = self._run self._run = os.path.basename( self.frame._img._raw.path).split(".pickle")[0].split("-")[-1] name_parts = os.path.basename( self._phil_destination_path).split(prev_run) name = name_parts[0] + self._run + name_parts[1] self._phil_destination_path = os.path.join( self._phil_destination_dir, name) wb = open(self._phil_destination_path, "wb") wb.write(b"integration {\n") wb.write(b" absorption_correction {\n") wb.write(b" apply = True\n") wb.write(b" algorithm = fuller_kapton\n") wb.write(b" fuller_kapton.xtal_height_above_kapton_mm {\n") wb.write(b" value = %f\n" % self._xtal_height_mm) wb.write(b" }\n") wb.write(b" fuller_kapton.rotation_angle_deg {\n") wb.write(b" value = %f\n" % self._tape_angle_deg) wb.write(b" }\n") wb.write(b" fuller_kapton.kapton_half_width_mm {\n") wb.write(b" value = %f\n" % self._tape_half_width_mm) wb.write(b" }\n") wb.write(b" fuller_kapton.kapton_thickness_mm {\n") wb.write(b" value = %f\n" % self._tape_thickness_mm) wb.write(b" }\n") wb.write(b" fuller_kapton.smart_sigmas = True\n") wb.write(b" }\n") wb.write(b"}\n") wb.close() print("Wrote phil snippet to", self._phil_destination_path) if not hasattr(self, "_root_frame") or self._root_frame is None: self._root_frame = self._pyslip.GetParent().GetParent() self._root_frame.OnNext(event) def _draw_shadow_layer(self, dc, data, map_rel): """Draw a points layer. dc the device context to draw on data an iterable of point tuples: (x, y, place, radius, colour, x_off, y_off, pdata) map_rel points relative to map if True, MUST BE TRUE for lightweight Assumes all points are the same colour, saving 100's of ms. """ assert map_rel is True if len(data) == 0: return (lon, lat, place, radius, colour, x_off, y_off, pdata) = data[0] scale = 2**self._pyslip.tiles.zoom_level # Draw points on map/view, using transparency if implemented. try: dc = wx.GCDC(dc) except NotImplementedError: pass dc.SetBrush(wx.Brush(colour, wx.TRANSPARENT)) for (lon, lat, place, radius, colour, x_off, y_off, pdata) in data: dc.SetPen(wx.Pen(colour)) (x, y) = self._pyslip.ConvertGeo2View((lon, lat)) dc.DrawCircle(x, y, 1) if colour == "purple": dc.DrawCircle(x, y, 10) pass def _draw_contours_layer(self, dc, data, map_rel): """Draw a layer consisting of differently colored contours. dc the device context to draw on data a list of dictionaries: {"Paths":[Path, Path, ...], "level":level, "color":color} each Path is an iterable of line segments to be overlaid on the pyslip image level is the contour level of the Paths colour is the colour to be applied to the contour lines at this level map_rel points relative to map if True, MUST BE TRUE for lightweight """ assert map_rel is True if len(data) == 0: return scale = 2**self._pyslip.tiles.zoom_level # Draw line segments of the appropriate color on the pyslip map object try: dc = wx.GCDC(dc) except NotImplementedError: pass for contour_level in data: path_list = contour_level["Paths"] level = contour_level["level"] colour = wx.Colour(*[(1 - decimal) * 255 for decimal in contour_level["colour"]]) dc.SetBrush(wx.Brush(colour)) dc.SetPen(wx.Pen(colour)) for path in path_list: segments = path.iter_segments() this_vertex = segments.next()[0] vertex_1 = self._pyslip.ConvertGeo2View( this_vertex) # x, y = Geo2View(lon, lat) while True: try: this_vertex = segments.next()[0] vertex_2 = self._pyslip.ConvertGeo2View( this_vertex) # x, y = Geo2View(lon, lat) dc.DrawLine(vertex_1[0], vertex_1[1], vertex_2[0], vertex_2[1]) vertex_1 = vertex_2 except StopIteration: break def _draw_edge_max_layer(self, dc, data, map_rel): """Draw a layer consisting of two line segments, identifying the Kapton absorption edge and max. dc the device context to draw on data a list of line segments (lon1, lat1, lon2, lat2) map_rel points relative to map if True, MUST BE TRUE for lightweight """ assert map_rel is True if len(data) == 0: return scale = 2**self._pyslip.tiles.zoom_level # Draw line segments on the pyslip map object try: dc = wx.GCDC(dc) except NotImplementedError: pass dc.SetBrush(wx.Brush("black")) dc.SetPen(wx.Pen("black")) for segment in data: lon1, lat1, lon2, lat2 = segment x1, y1 = self._pyslip.ConvertGeo2View((lon1, lat1)) x2, y2 = self._pyslip.ConvertGeo2View((lon2, lat2)) dc.DrawLine(x1, y1, x2, y2) def _map_coords(self, x, y, p): y, x = self._pyslip.tiles.flex_image.tile_readout_to_picture( p, y - 0.5, x - 0.5) return self._pyslip.tiles.picture_fast_slow_to_map_relative(x, y) def UpdateAbsorptionData(self, edge_max_mode=False): from scitbx.array_family import flex #from IPython import embed; embed(); exit() self.update_absorption( ) # basically resets the self._absorption to a new KaptonTape class self.absorption_data = [] if True: #not hasattr(self, 'cache_mode'): self.cache_mode = True self.all_s1_flex = flex.vec3_double() #self.all_lon_lat=[] #FIXME detector = self._pyslip.tiles.raw_image.get_detector() for panel in detector: image_size = panel.get_image_size() for f_dir in range(0, image_size[0], 10): for s_dir in range(0, image_size[1], 10): s1 = panel.get_pixel_lab_coord((f_dir, s_dir)) #self.all_s1_flex.append(s1) lon, lat = self._map_coords(float(f_dir), float(s_dir), panel.index()) #self.all_lon_lat.append((lon,lat)) #self.cache_mode=True absorption_correction = self._absorption.abs_correction( s1) self.absorption_data.append( (lon, lat, absorption_correction)) #absorption_corrections = self._absorption.abs_correction_flex(self.all_s1_flex) #self.absorption_data=[(x[0],x[1],y) for x,y in zip(self.all_lon_lat, absorption_corrections)] # Redraw layers if present if (hasattr(self, "_shadow_layer") and self._shadow_layer is not None): self.DrawShadow() if (hasattr(self, "_contours_layer") and self._contours_layer is not None): self.DrawContours() if (hasattr(self, "_edge_max_layer") and self._edge_max_layer is not None): self.DrawEdgeMax() def DrawShadow(self): if not hasattr(self, 'absorption_data'): self.UpdateAbsorptionData() shadow_data = [] shadow_data.append((self.center_lon_lat[0], self.center_lon_lat[1], { "colour": "purple" })) for lon, lat, absorption_correction in self.absorption_data: if absorption_correction == 1: colour = "white" elif absorption_correction < 1.2: colour = "blue" elif absorption_correction < 1.4: colour = "green" elif absorption_correction < 1.6: colour = "yellow" elif absorption_correction < 1.8: colour = "orange" else: colour = "red" shadow_data.append((lon, lat, {"colour": colour})) # Remove the old shadow layer, and draw a new one. if (hasattr(self, "_shadow_layer") and self._shadow_layer is not None): self._pyslip.DeleteLayer(self._shadow_layer) self._shadow_layer = None self._shadow_layer = self._pyslip.AddPointLayer( shadow_data, map_rel=True, visible=True, show_levels=[-3, -2, -1, 0, 1, 2, 3, 4, 5], renderer=self._draw_shadow_layer, name="<shadow_layer>") def DrawContours(self): if not hasattr(self, 'absorption_data'): self.UpdateAbsorptionData() import matplotlib.pyplot as plt print( 'DrawContours does not work currently. Please try the other options' ) return def convert_to_tile(slow_fast_ab_tup): slow, fast, ab = slow_fast_ab_tup local_lon, local_lat = self._pyslip.tiles.picture_fast_slow_to_map_relative( fast, slow) return (local_lon, local_lat, ab) lon, lat, absorptions = zip( *map(convert_to_tile, self.absorption_data)) n_lon = len(set(lon)) n_lat = len(set(lat)) indices = [] if lon[0] == lon[1]: indices = [[i_lon * n_lat + i_lat for i_lat in range(0, n_lat, 1)] for i_lon in range(0, n_lon, 1)] elif lat[0] == lat[1]: indices = [[i_lat * n_lon + i_lon for i_lon in range(0, n_lon, 1)] for i_lat in range(0, n_lat, 1)] else: # appears to be a non-rectangular array indices = [range(n_lon * n_lat)] lon_array = [[lon[i] for i in l] for l in indices] lat_array = [[lat[i] for i in l] for l in indices] abs_array = [[absorptions[i] for i in l] for l in indices] contours = plt.contour(lon_array, lat_array, abs_array) levels = list(contours.levels) def convert_level_to_rgb_colour(level): r, g, b, a = contours.cmap(level - 1) return (r, g, b) colours = map(convert_level_to_rgb_colour, levels) contour_paths = [{ "Paths": contours.collections[i].get_paths(), "level": levels[i], "colour": colours[i] } for i in range(len(contours.collections))] # Remove the old contours layer, and draw a new one. if (hasattr(self, "_contours_layer") and self._contours_layer is not None): self._pyslip.DeleteLayer(self._contours_layer) self._contours_layer = None self._contours_layer = self._pyslip.AddLayer( self._draw_contours_layer, contour_paths, True, #map_rel True, #visible [-3, -2, -1, 0, 1, 2, 3, 4, 5], #show_levels False, #selectable "<contours_layer>", #name "contours") def DrawEdgeMax(self): if not hasattr(self, 'absorption_data'): self.UpdateAbsorptionData(edge_max_mode=True) detector = self._pyslip.tiles.raw_image.get_detector() beam = self._pyslip.tiles.raw_image.get_beam() xrayframe = self.GetParent().GetParent() int_with_det = self._absorption.abs_bounding_lines_on_image(detector) s0 = beam.get_s0() panel_id, beam_pixel_fast, beam_pixel_slow = xrayframe.get_beam_center_px( ) if len(detector) > 1: beam_pixel_slow, beam_pixel_fast = xrayframe.pyslip.tiles.flex_image.tile_readout_to_picture( panel_id, beam_pixel_slow - 0.5, beam_pixel_fast - 0.5) int_with_det_px = [] edge_max_data_slow_fast = [] def panel_of_intersection(elem, detector): """Takes in x1,y1,x2,y2 and returns the panel where these points lie. If outside any panel then returns None""" x1, y1, x2, y2 = elem # FIXME tolerance levels, a bit hacky d1 = 3.09 d2 = -0.09 int_panels = [None, None] for panel in detector: # Convert x,y to f,s for that panel z_panel = panel.get_distance() ori = col(panel.get_origin()) r1 = col((x1, y1, -z_panel)) - ori r2 = col((x2, y2, -z_panel)) - ori f_u = col(panel.get_fast_axis()) s_u = col(panel.get_slow_axis()) f1 = r1.dot(f_u) s1 = r1.dot(s_u) f2 = r2.dot(f_u) s2 = r2.dot(s_u) detz = panel.get_distance() px1 = panel.get_ray_intersection_px((f1, s1, -detz)) px2 = panel.get_ray_intersection_px((f2, s2, -detz)) if px1[0]/panel.get_image_size()[0]<=d1 and px1[0]/panel.get_image_size()[0] >=d2 and \ px1[1]/panel.get_image_size()[1]<=d1 and px1[1]/panel.get_image_size()[1] >=d2: int_panels[0] = panel if px2[0]/panel.get_image_size()[0]<=d1 and px2[0]/panel.get_image_size()[0] >=d2 and \ px2[1]/panel.get_image_size()[1]<=d1 and px2[1]/panel.get_image_size()[1] >=d2: int_panels[1] = panel #from IPython import embed; embed(); exit() # FIXME if int_panels[0] is None and int_panels[1] is None: from libtbx.utils import Sorry raise Sorry( "No intersecting panels ?? this is awful .. get out of here" ) if int_panels[0] is None: int_panels[0] = int_panels[1] if int_panels[1] is None: int_panels[1] = int_panels[0] return int_panels for elem in int_with_det: # Determine panel number for pts 1 and 2 p1, p2 = panel_of_intersection(elem, detector) pixel_size_1 = p1.get_pixel_size()[0] pixel_size_2 = p2.get_pixel_size()[0] if True: # for panel 1 z_panel = p1.get_distance() ori = col(p1.get_origin()) r1 = col((elem[0], elem[1], -z_panel)) - ori f1_u = col(p1.get_fast_axis()) s1_u = col(p1.get_slow_axis()) f1 = r1.dot(f1_u) s1 = r1.dot(s1_u) # For panel 2 z_panel = p2.get_distance() ori = col(p2.get_origin()) r2 = col((elem[2], elem[3], -z_panel)) - ori f2_u = col(p2.get_fast_axis()) s2_u = col(p2.get_slow_axis()) f2 = r2.dot(f2_u) s2 = r2.dot(s2_u) if True: # FIXME is this correct to comment out beam_pixel_fast / beam_pixel_slow px_f1 = f1 / pixel_size_1 #+beam_pixel_fast px_s1 = s1 / pixel_size_1 #+beam_pixel_slow px_f2 = f2 / pixel_size_2 #+beam_pixel_fast px_s2 = s2 / pixel_size_2 #+beam_pixel_slow # If debugging if False: px_f1 = beam_pixel_fast px_s1 = beam_pixel_slow px_f2 = beam_pixel_fast + 100 px_s2 = beam_pixel_slow edge_max_data_slow_fast.append( (px_s1, px_f1, p1.index(), px_s2, px_f2, p2.index())) edge_max_data_lonlat = [] kapton_data = [] for segment in edge_max_data_slow_fast: slow1, fast1, p1, slow2, fast2, p2 = segment lon1, lat1 = self._map_coords( fast1, slow1, p1 ) #self._pyslip.tiles.picture_fast_slow_to_map_relative(fast1, slow1) lon2, lat2 = self._map_coords( fast2, slow2, p2 ) #self._pyslip.tiles.picture_fast_slow_to_map_relative(fast2, slow2) edge_max_data_lonlat.append((lon1, lat1, lon2, lat2)) shoebox_dict = {'width': 2, 'color': '#0000FFA0', 'closed': False} if False: x0_, y0_ = lon1, lat1 x1_, y1_ = lon2, lat2 my_attrs = dict(shoebox_dict) lines = [(((x0_, y0_), (x0_, y1_)), my_attrs), (((x0_, y1_), (x1_, y1_)), my_attrs), (((x1_, y1_), (x1_, y0_)), my_attrs), (((x1_, y0_), (x0_, y0_)), my_attrs)] kapton_data.extend(lines) if False: self.edge_max_layer = self._pyslip.AddPolygonLayer( kapton_data, map_rel=True, visible=True, show_levels=[-3, -2, -1, 0, 1, 2, 3, 4, 5], selectable=False, name='<kapton_layer>', update=False) # Remove the old edge_max layer, and draw a new one. if (hasattr(self, "_edge_max_layer") and self._edge_max_layer is not None): self._pyslip.DeleteLayer(self._edge_max_layer) self._edge_max_layer = None if True: self._edge_max_layer = self._pyslip.AddLayer( self._draw_edge_max_layer, edge_max_data_lonlat, map_rel=True, #map_rel visible=True, #visible show_levels=[-3, -2, -1, 0, 1, 2, 3, 4, 5], #show_levels selectable=False, #selectable name="<edge_max_layer>", type="edge_max")