def show_settings(self):
"""Change the UI elements to match the current display settings and other options.
Should be called when creating the form.
"""
self._inside_show_settings = True
#- Display settings
# @type param ParamReflectionDisplay
param = display_thread.get_reflection_display_params()
self.panel.radioPixels.SetValue(param.display_as == param.DISPLAY_AS_PIXELS)
self.panel.radioSpheres.SetValue(param.display_as == param.DISPLAY_AS_SPHERES)
self.panel.radioMeasured.SetValue(param.color_map == param.COLOR_BY_MEASURED)
self.panel.radioPredicted.SetValue(param.color_map == param.COLOR_BY_PREDICTED)
self.panel.sliderSize.SetValue(10. * param.size)
self.panel.sliderSize.Enable(not param.automatic_size)
self.panel.checkAutoSize.SetValue(param.automatic_size)
#- Masking settings
# @type param ParamReflectionMasking
param = display_thread.get_reflection_masking_params()
self.panel.choiceView.Select(param.masking_type)
self.panel.textThreshold.SetValue( "%.2f" % param.threshold)
#Slice settings
self.panel.checkShowSlice.SetValue(param.use_slice)
self.panel.sliceControl.use_slice = param.use_slice
self.panel.sliceControl.slice_min = param.slice_min
self.panel.sliceControl.slice_max = param.slice_max
self._inside_show_settings = False
def onPanel3DSize(self, event):
#The 3d view is resized
if not self.controller.in_volume_mode():
param = display_thread.get_reflection_display_params()
#Only redraw for automatic pixel size
if param.automatic_size and param.display_as == model.experiment.ParamReflectionDisplay.DISPLAY_AS_PIXELS:
self.controller.auto_adjust_pixel_size()
event.Skip()
def auto_adjust_pixel_size(self):
"""Change the size of the pixels drawn to make them look good on screen.
Call this when the window is resized or when the # of points plotted changes."""
#Figure out a good pixel size
(w, h) = self.scene.render_window.size
diag = np.sqrt(w * w + h * h)
display = display_thread.get_reflection_display_params()
pixel_size = diag / 300. # * (display.size / 5.)
self.points_module_surface.actor.property.set(representation='points',
point_size=pixel_size)
#Update the GUI
self.parent_frame.tabReflections.change_displayed_size(pixel_size)
def in_pixel_mode(self):
"""Return True if we are in pixel point view mode."""
# @type display ParamReflectionDisplay
display = display_thread.get_reflection_display_params()
return display.display_as == display.DISPLAY_AS_PIXELS
def update_data_points(self, *args):
"""Called when a message is received saying that the q-space
calculation has changed.
Will update the graphical display. TO SHOW POINTS!!
"""
#Do we need to adjust which elements are visible?
change_visibility = not self.in_volume_mode()
#No GUI updates while we work
self.scene.disable_render = True
if change_visibility:
#Hide the iso surface
self.iso.visible = False
#Ensure visibility of warning text
self.warning_text.visible = self.warning_text_visible
#Get the display parameters last saved.
# @type display ParamReflectionDisplay
display = display_thread.get_reflection_display_params()
#Generate a new data object to make
self.point_data_src.data = self.make_point_data()
#Set the color map
self.set_points_lut(display.color_map == display.COLOR_BY_PREDICTED)
if self.in_pixel_mode():
# ------------ Pixel View -----------------------
self.pixel_view = True
if change_visibility:
#Hide the sphere view, show the points
self.points_module_glyph.visible = False
self.points_module_surface.visible = True
#Change the pixel size
if display.automatic_size:
self.auto_adjust_pixel_size()
else:
#Directly use the value
pixel_size = round(display.size)
self.points_module_surface.actor.property.set(
representation='points', point_size=pixel_size)
#Make sure the highlight cubes are okay sized
self.resize_highlighting_cubes(self.get_best_sphere_size())
else:
# ------------ Sphere View -----------------------
self.pixel_view = False
if change_visibility:
#Hide the points view, show the spheres
self.points_module_glyph.visible = True
self.points_module_surface.visible = False
#Change the radius of the spheres
if display.automatic_size:
self.auto_adjust_sphere_size()
else:
#Use the number given
sphere_size = display.size * self.SPHERE_SCALING
self.points_module_glyph.glyph.glyph_source.glyph_source.radius = sphere_size
self.resize_highlighting_cubes(sphere_size)
# Doc says: Call this function when you change the array data in-place.
# This call should update the MayaVi views.
# NOTE! Calling this from a different thread seems to crash.
self.point_data_src.update()
#Make sure the color scale is good
self.fix_colorscale(self.points_module_surface)
#This will redraw now.
self.scene.disable_render = False
self.point_data_needs_updating = False
def make_point_data(self):
"""Generate the point data object (type tvtk.PolyData) that is needed by the
VTKDataSource to display the points (reflections)."""
pd = tvtk.PolyData()
ref_q = model.experiment.exp.reflections_q_vector
mask = model.experiment.exp.reflections_mask
if not isinstance(ref_q, np.ndarray):
#No array = return an empty data set
return pd
assert len(
model.experiment.exp.reflections_times_measured_with_equivalents
) == len(
mask
), "Reflection mask and times measured should be the same length."
#How many of the points are kept?
num = np.sum(mask)
#Are there more points than the configuration allows?
num_wanted = config_gui.cfg.max_3d_points
if num > num_wanted:
#Adjust the mask to show only so many points
indices = np.nonzero(mask)[0]
#Randomize list of indices
np.random.shuffle(indices)
#Keep only the # wanted
indices = indices[0:num_wanted]
#Re-generate a smaller mask
mask = mask.copy(
) #Must copy the array, otherwise we are modifying the source one
mask &= 0
mask[indices] = True
#Display a warning
self.warning_text.text = "(Points thinned down from %d to %d)" % (
num, num_wanted)
self.warning_text_visible = True
#Make sure the number is correct
num = num_wanted
else:
#No problem
self.warning_text_visible = False
self.warning_text.visible = self.warning_text_visible
if num <= 0:
#Nothing to show!
return pd
else:
#Positions = our array of q-vectors.
# .T = transpose
pd.points = ref_q[:, mask].T
#Create the vertices
verts = np.arange(0, num, 1)
verts.shape = (num, 1)
pd.verts = verts
#Put the # of times measured here as the scalar data
param = display_thread.get_reflection_masking_params(
) #@type param ParamReflectionMasking
param_display = display_thread.get_reflection_display_params(
) #@type param_display ParamReflectionDisplay
if param_display.color_map == param_display.COLOR_BY_PREDICTED:
#--- Color using the predicted measurements ---
if param.show_equivalent_reflections:
#SHow times measured COUNTING equivalent (symmetrical) reflections.
pd.point_data.scalars = model.experiment.exp.reflections_times_measured_with_equivalents[
mask, :]
else:
# Show only the times measured for the exact reflection
pd.point_data.scalars = model.experiment.exp.reflections_times_measured[
mask, :]
else:
#--- Color using the real measurements ----
if param.show_equivalent_reflections:
#SHow times measured COUNTING equivalent (symmetrical) reflections.
pd.point_data.scalars = model.experiment.exp.reflections_times_real_measured_with_equivalents[
mask, :]
else:
# Show only the times measured for the exact reflection
pd.point_data.scalars = model.experiment.exp.reflections_times_real_measured[
mask, :]
pd.point_data.scalars.name = 'scalars'
return pd