sas.qtgui.Plotting package

Subpackages

Submodules

sas.qtgui.Plotting.AddText module

class sas.qtgui.Plotting.AddText.AddText(parent=None)[source]

Bases: QDialog, Ui_AddText

Simple GUI for a single line text query

__annotations__ = {}
__doc__ = ' Simple GUI for a single line text query '
__init__(parent=None)[source]
__module__ = 'sas.qtgui.Plotting.AddText'
color()[source]
font(self) QFont[source]
onColorChange(event)[source]

Pop up the standard Qt color change dialog

onFontChange(event)[source]

Pop up the standard Qt Font change dialog

text()[source]

sas.qtgui.Plotting.Arrow3D module

Module that draws multiple arrows in 3D coordinates

class sas.qtgui.Plotting.Arrow3D.Arrow3D(base, xs, ys, zs, colors, *args, **kwargs)[source]

Bases: FancyArrowPatch

Draw 3D arrow

__doc__ = '\n    Draw 3D arrow\n    '
__init__(base, xs, ys, zs, colors, *args, **kwargs)[source]

Init

Params xs:

[[x0, x0+dx0], [x1, x1+dx1], …]

Params ys:

[[y0, y0+dy0], [y1, y1+dy1], …]

Params zs:

[[z0, z0+dz0], [z1, z1+dz1], …]

Params colors:

[[R0, G0, B0], [R1, G1, B1], …]

where R, G, B ranges (0,1)

__module__ = 'sas.qtgui.Plotting.Arrow3D'
do_3d_projection()[source]

Drawing actually happens here

on_left_down(event)[source]

Mouse left-down event

on_left_up(event)[source]

Mouse left up event

set(*, agg_filter=<UNSET>, alpha=<UNSET>, animated=<UNSET>, antialiased=<UNSET>, arrowstyle=<UNSET>, capstyle=<UNSET>, clip_box=<UNSET>, clip_on=<UNSET>, clip_path=<UNSET>, color=<UNSET>, connectionstyle=<UNSET>, edgecolor=<UNSET>, facecolor=<UNSET>, fill=<UNSET>, gid=<UNSET>, hatch=<UNSET>, in_layout=<UNSET>, joinstyle=<UNSET>, label=<UNSET>, linestyle=<UNSET>, linewidth=<UNSET>, mouseover=<UNSET>, mutation_aspect=<UNSET>, mutation_scale=<UNSET>, patchA=<UNSET>, patchB=<UNSET>, path_effects=<UNSET>, picker=<UNSET>, positions=<UNSET>, rasterized=<UNSET>, realtime=<UNSET>, sketch_params=<UNSET>, snap=<UNSET>, transform=<UNSET>, url=<UNSET>, visible=<UNSET>, zorder=<UNSET>)

Set multiple properties at once.

Supported properties are

Properties:

agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array and two offsets from the bottom left corner of the image alpha: scalar or None animated: bool antialiased or aa: bool or None arrowstyle: str or matplotlib.patches.ArrowStyle capstyle: .CapStyle or {‘butt’, ‘projecting’, ‘round’} clip_box: .Bbox clip_on: bool clip_path: Patch or (Path, Transform) or None color: color connectionstyle: [ ‘arc3’ | ‘angle3’ | ‘angle’ | ‘arc’ | ‘bar’ ] edgecolor or ec: color or None facecolor or fc: color or None figure: .Figure fill: bool gid: str hatch: {‘/’, ‘\’, ‘|’, ‘-’, ‘+’, ‘x’, ‘o’, ‘O’, ‘.’, ‘*’} in_layout: bool joinstyle: .JoinStyle or {‘miter’, ‘round’, ‘bevel’} label: object linestyle or ls: {‘-’, ‘–’, ‘-.’, ‘:’, ‘’, (offset, on-off-seq), …} linewidth or lw: float or None mouseover: bool mutation_aspect: float mutation_scale: float patchA: .patches.Patch patchB: .patches.Patch path_effects: .AbstractPathEffect picker: None or bool or float or callable positions: unknown rasterized: bool realtime: unknown sketch_params: (scale: float, length: float, randomness: float) snap: bool or None transform: .Transform url: str visible: bool zorder: float

set_realtime(realtime)[source]

Bool specifying whether arrows should be shown rotating while dragging is in progress May be slow for large numbers of arrows

update_data(xs, ys, zs)[source]

sas.qtgui.Plotting.Binder module

Extension to MPL to support the binding of artists to key/mouse events.

class sas.qtgui.Plotting.Binder.BindArtist(figure)[source]

Bases: object

__call__(trigger, artist, action)[source]

Register a callback for an artist to a particular trigger event.

usage:

self.connect(eventname,artist,action)

where:

eventname is a string artist is the particular graph object to respond to the event action(event,**kw) is called when the event is triggered

The action callback is associated with particular artists. Different artists will have different kwargs. See documentation on the contains() method for each artist. One common properties are ind for the index of the item under the cursor, which is returned by Line2D and by collections.

The following events are supported:

enter: mouse cursor moves into the artist or to a new index leave: mouse cursor leaves the artist click: mouse button pressed on the artist drag: mouse button pressed on the artist and cursor moves release: mouse button released for the artist key: key pressed when mouse is on the artist keyrelease: key released for the artist

The event received by action has a number of attributes:

name is the event name which was triggered artist is the object which triggered the event x,y are the screen coordinates of the mouse xdata,ydata are the graph coordinates of the mouse button is the mouse button being pressed/released key is the key being pressed/released shift,control,alt,meta are flags which are true if the

corresponding key is pressed at the time of the event.

details is a dictionary of artist specific details, such as the

id(s) of the point that were clicked.

When receiving an event, first check the modifier state to be sure it applies. E.g., the callback for ‘press’ might be:

if event.button == 1 and event.shift: process Shift-click

TODO: Only receive events with the correct modifiers (e.g., S-click, TODO: or -click for any modifiers). TODO: Only receive button events for the correct button (e.g., click1 TODO: release3, or dclick for any button) TODO: Support virtual artist, so that and artist can be flagged as TODO: having a tag list and receive the correct events TODO: Support virtual events for binding to button-3 vs shift button-1 TODO: without changing callback code TODO: Attach multiple callbacks to the same event? TODO: Clean up interaction with toolbar modes TODO: push/pushclear/pop context so that binding changes for

the duration

TODO: e.g., to support ? context sensitive help

__del__()[source]
__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Binder', '__doc__': '\n    ', 'control': False, 'shift': False, 'alt': False, 'meta': False, 'dclick_threshhold': 0.25, '_last_button': None, '_last_time': 0, 'events': ['enter', 'leave', 'motion', 'click', 'dclick', 'drag', 'release', 'scroll', 'key', 'keyup'], '__init__': <function BindArtist.__init__>, 'clear': <function BindArtist.clear>, 'clearall': <function BindArtist.clearall>, 'disconnect': <function BindArtist.disconnect>, '__del__': <function BindArtist.__del__>, '__call__': <function BindArtist.__call__>, 'trigger': <function BindArtist.trigger>, '_find_current': <function BindArtist._find_current>, '_onMotion': <function BindArtist._onMotion>, '_onClick': <function BindArtist._onClick>, '_onDClick': <function BindArtist._onDClick>, '_onRelease': <function BindArtist._onRelease>, '_onKey': <function BindArtist._onKey>, '_onKeyRelease': <function BindArtist._onKeyRelease>, '_onScroll': <function BindArtist._onScroll>, '__dict__': <attribute '__dict__' of 'BindArtist' objects>, '__weakref__': <attribute '__weakref__' of 'BindArtist' objects>, '__annotations__': {}})
__doc__ = '\n    '
__init__(figure)[source]
__module__ = 'sas.qtgui.Plotting.Binder'
__weakref__

list of weak references to the object

_find_current(event)[source]

Find the artist who will receive the event. Only search registered artists. All others are invisible to the mouse.

_last_button = None
_last_time = 0
_onClick(event)[source]

Process button click

_onDClick(event)[source]

Process button double click

_onKey(event)[source]

Process key click

_onKeyRelease(event)[source]

Process key release

_onMotion(event)[source]

Track enter/leave/motion through registered artists; all other artists are invisible.

_onRelease(event)[source]

Process release release

_onScroll(event)[source]

Process scroll event

alt = False
clear(h1, h2, ...)[source]

Remove connections for artists h1, h2, …

Use clearall() to reset all connections.

clearall()[source]

Clear connections to all artists.

Use clear(h1,h2,…) to reset specific artists.

control = False
dclick_threshhold = 0.25
disconnect()[source]

In case we need to disconnect from the canvas…

events = ['enter', 'leave', 'motion', 'click', 'dclick', 'drag', 'release', 'scroll', 'key', 'keyup']
meta = False
shift = False
trigger(actor, action, ev)[source]

Trigger a particular event for the artist. Fallback to axes, to figure, and to ‘all’ if the event is not processed.

class sas.qtgui.Plotting.Binder.Selection(artist=None, prop={})[source]

Bases: object

Store and compare selections.

__bool__()[source]
__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Binder', '__doc__': '\n    Store and compare selections.\n    ', 'artist': None, 'prop': {}, '__init__': <function Selection.__init__>, '__eq__': <function Selection.__eq__>, '__ne__': <function Selection.__ne__>, '__bool__': <function Selection.__bool__>, '__dict__': <attribute '__dict__' of 'Selection' objects>, '__weakref__': <attribute '__weakref__' of 'Selection' objects>, '__hash__': None, '__annotations__': {}})
__doc__ = '\n    Store and compare selections.\n    '
__eq__(other)[source]

Return self==value.

__hash__ = None
__init__(artist=None, prop={})[source]
__module__ = 'sas.qtgui.Plotting.Binder'
__ne__(other)[source]

Return self!=value.

__weakref__

list of weak references to the object

artist = None
prop = {}

sas.qtgui.Plotting.BoxSum module

sas.qtgui.Plotting.ColorMap module

sas.qtgui.Plotting.ConvertUnits module

Convert units to strings that can be displayed This is a cleaned up version of unitConverter.py

sas.qtgui.Plotting.ConvertUnits.convertUnit(power, unit)[source]

Convert units to strings that can be displayed

sas.qtgui.Plotting.DataTransform module

sas.qtgui.Plotting.DataTransform.errFromX2(x, y=None, dx=None, dy=None)[source]

calculate error of sqrt(x)

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errFromX4(x, y=None, dx=None, dy=None)[source]

calculate error of x^1/4

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errOneOverSqrtX(x, y=None, dx=None, dy=None)[source]

Calculate error on 1/sqrt(x)

sas.qtgui.Plotting.DataTransform.errOneOverX(x, y=None, dx=None, dy=None)[source]

calculate error on 1/x

sas.qtgui.Plotting.DataTransform.errToLog10X(x, y=None, dx=None, dy=None)[source]

calculate error of Log(x)

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToLogX(x, y=None, dx=None, dy=None)[source]

calculate error of Log(x)

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToLogXY(x, y, dx=None, dy=None)[source]

calculate error of Log(xy)

sas.qtgui.Plotting.DataTransform.errToLogYX2(y, x, dy=None, dx=None)[source]

calculate error of Log(yx**2)

sas.qtgui.Plotting.DataTransform.errToLogYX4(y, x, dy=None, dx=None)[source]

error for ln(y*x^(4))

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.errToX(x, y=None, dx=None, dy=None)[source]

calculate error of x**2

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToX2(x, y=None, dx=None, dy=None)[source]

calculate error of x**2

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToX4(x, y=None, dx=None, dy=None)[source]

calculate error of x**4

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToX_pos(x, y=None, dx=None, dy=None)[source]

calculate error of x**2

Parameters:
  • x – float value

  • dx – float value

sas.qtgui.Plotting.DataTransform.errToYX2(y, x, dy=None, dx=None)[source]
sas.qtgui.Plotting.DataTransform.errToYX4(y, x, dy=None, dx=None)[source]

error for (y*x^(4))

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.fromX2(x, y=None)[source]

This function is used to load value on Plottable.View Calculate square root of x

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.fromX4(x, y=None)[source]

This function is used to load value on Plottable.View Calculate square root of x

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.toLogX(x, y=None)[source]

This function is used to load value on Plottable.View calculate log x

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.toLogXY(y, x)[source]

This function is used to load value on Plottable.View calculate log x

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.toLogYX2(y, x)[source]
sas.qtgui.Plotting.DataTransform.toLogYX4(y, x)[source]
sas.qtgui.Plotting.DataTransform.toOneOverSqrtX(y, x=None)[source]
sas.qtgui.Plotting.DataTransform.toOneOverX(x, y=None)[source]
sas.qtgui.Plotting.DataTransform.toX(x, y=None)[source]

This function is used to load value on Plottable.View

Parameters:

x – Float value

Returns:

x

sas.qtgui.Plotting.DataTransform.toX2(x, y=None)[source]

This function is used to load value on Plottable.View

Calculate x^(2)

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.toX4(x, y=None)[source]

This function is used to load value on Plottable.View

Calculate x^(4)

Parameters:

x – float value

sas.qtgui.Plotting.DataTransform.toX_pos(x, y=None)[source]

This function is used to load value on Plottable.View

Parameters:

x – Float value

Returns:

x

sas.qtgui.Plotting.DataTransform.toYX2(y, x)[source]
sas.qtgui.Plotting.DataTransform.toYX4(y, x)[source]

sas.qtgui.Plotting.Fittings module

This module is used to fit a set of x,y data to a model passed to it. It is used to calculate the slope and intercepts for the linearized fits. Two things should be noted:

First, this fitting module uses the NLLSQ module of SciPy rather than a linear fit. This along with a few other modules could probably be removed if we move to a linear regression approach.

Second, this infrastructure does not allow for resolution smearing of the the models. Hence the results are not that accurate even for pinhole collimation of SANS but may be good for SAXS. It is completely wrong for slit smeared data.

class sas.qtgui.Plotting.Fittings.Parameter(model, name, value=None)[source]

Bases: object

Class to handle model parameters - sets the parameters and their initial value from the model based to it.

__call__()[source]

Return the current value of the parameter

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Fittings', '__doc__': '\n    Class to handle model parameters - sets the parameters and their\n    initial value from the model based to it.\n    ', '__init__': <function Parameter.__init__>, 'set': <function Parameter.set>, '__call__': <function Parameter.__call__>, '__dict__': <attribute '__dict__' of 'Parameter' objects>, '__weakref__': <attribute '__weakref__' of 'Parameter' objects>, '__annotations__': {}})
__doc__ = '\n    Class to handle model parameters - sets the parameters and their\n    initial value from the model based to it.\n    '
__init__(model, name, value=None)[source]
__module__ = 'sas.qtgui.Plotting.Fittings'
__weakref__

list of weak references to the object

set(value)[source]

Set the value of the parameter

sas.qtgui.Plotting.Fittings.calcCommandline(event)[source]
sas.qtgui.Plotting.Fittings.sasfit(model, pars, x, y, err_y, qmin=None, qmax=None)[source]

Fit function

Parameters:
  • model – sas model object

  • pars – list of parameters

  • x – vector of x data

  • y – vector of y data

  • err_y – vector of y errors

sas.qtgui.Plotting.LineModel module

Provide Line function (y= Ax + B). Until July 10, 2016 this function provided (y= A + Bx). This however was contrary to all the other code using it which assumed (y= mx+b) or in this nomenclature (y=Ax + B). This lead to some contortions in the code and worse incorrect calculations until now for at least some of the functions. This seemed the easiest to fix particularly since this function should disappear in a future iteration (see notes in fitDialog)

-PDB

July 10, 2016

class sas.qtgui.Plotting.LineModel.LineModel[source]

Bases: object

Class that evaluates a linear model.

\(f(x) = Ax + B\)

List of default parameters: A = 1.0 B = 1.0

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.LineModel', '__doc__': '\n    Class that evaluates a linear model.\n\n    $f(x) = Ax + B$\n\n    List of default parameters:\n    A = 1.0\n    B = 1.0\n    ', '__init__': <function LineModel.__init__>, 'getParam': <function LineModel.getParam>, 'setParam': <function LineModel.setParam>, '_line': <function LineModel._line>, 'run': <function LineModel.run>, 'runXY': <function LineModel.runXY>, '__dict__': <attribute '__dict__' of 'LineModel' objects>, '__weakref__': <attribute '__weakref__' of 'LineModel' objects>, '__annotations__': {}})
__doc__ = '\n    Class that evaluates a linear model.\n\n    $f(x) = Ax + B$\n\n    List of default parameters:\n    A = 1.0\n    B = 1.0\n    '
__init__()[source]

Initialization

__module__ = 'sas.qtgui.Plotting.LineModel'
__weakref__

list of weak references to the object

_line(x)[source]

Evaluate the function

Parameters:

x – x-value

Returns:

function value

getParam(name)[source]

Return parameter value

run(x=0.0)[source]

Evaluate the model

Parameters:

x – simple value

Returns:

(Line value)

Note

This is the function called by fitDialog to calculate the the y(xmin) and y(xmax), but the only difference between this and runXY is when the if statement is true. I however cannot see what that function is for. It needs to be documented here or removed. -PDB 7/10/16

runXY(x=0.0)[source]

Evaluate the model.

Parameters:

x – simple value

Returns:

Line value

..note::

This is to be what is called by fitDialog for the actual fit but the only difference between this and run is when the if statement is true. I however cannot see what that function is for. It needs to be documented here or removed. -PDB 7/10/16

setParam(name, value)[source]

Set parameter value

sas.qtgui.Plotting.LinearFit module

sas.qtgui.Plotting.MaskEditor module

sas.qtgui.Plotting.PlotHelper module

Singleton plot helper module All its variables are bound to the module, which can not be instantiated repeatedly so IDs are session-specific.

sas.qtgui.Plotting.PlotHelper.addPlot(plot)[source]

Adds a new plot to the current dictionary of plots

sas.qtgui.Plotting.PlotHelper.clear()[source]

Reset the plot dictionary

sas.qtgui.Plotting.PlotHelper.currentPlots()[source]

Returns a list of IDs for all currently active plots

sas.qtgui.Plotting.PlotHelper.deletePlot(plot_id)[source]

Deletes an existing plot from the dictionary

sas.qtgui.Plotting.PlotHelper.idOfPlot(plot)[source]

Returns the ID of the plot

sas.qtgui.Plotting.PlotHelper.plotById(plot_id)[source]

Returns the plot referenced by the ID

sas.qtgui.Plotting.PlotProperties module

class sas.qtgui.Plotting.PlotProperties.PlotProperties(parent=None, color=0, marker=0, marker_size=5, legend='')[source]

Bases: QDialog, Ui_PlotPropertiesUI

Dialog for modification of single plot properties

__annotations__ = {}
__doc__ = ' Dialog for modification of single plot properties '
__init__(parent=None, color=0, marker=0, marker_size=5, legend='')[source]
__module__ = 'sas.qtgui.Plotting.PlotProperties'
color()[source]

return current color: index in COLORS or a hex string

legend()[source]

return current legend

marker()[source]

return the current shape index in SHAPE

markersize()[source]

return marker size (int)

onColorChange()[source]

Pop up the standard Qt color change dialog

onColorIndexChange()[source]

Dynamically add/remove “Custom” color index

sas.qtgui.Plotting.PlotUtilities module

sas.qtgui.Plotting.PlotUtilities.build_matrix(data, qx_data, qy_data)[source]

Build a matrix for 2d plot from a vector Returns a matrix (image) with ~ square binning Requirement: need 1d array formats of data, qx_data, and qy_data where each one corresponds to z, x, or y axis values

sas.qtgui.Plotting.PlotUtilities.fillupPixels(image=None, weights=None)[source]

Fill z values of the empty cells of 2d image matrix with the average over up-to next nearest neighbor points

Parameters:

image – (2d matrix with some zi = None)

Returns:

image (2d array )

TODO:

Find better way to do for-loop below

sas.qtgui.Plotting.PlotUtilities.getValidColor(color)[source]

Returns a valid matplotlib color

sas.qtgui.Plotting.PlotUtilities.get_bins(qx_data, qy_data)[source]

get bins return x_bins and y_bins: 1d arrays of the index with ~ square binning Requirement: need 1d array formats of qx_data, and qy_data where each one corresponds to x, or y axis values

sas.qtgui.Plotting.PlotUtilities.rescale(lo, hi, step, pt=None, bal=None, scale='linear')[source]

Rescale (lo,hi) by step, returning the new (lo,hi) The scaling is centered on pt, with positive values of step driving lo/hi away from pt and negative values pulling them in. If bal is given instead of point, it is already in [0,1] coordinates.

This is a helper function for step-based zooming.

sas.qtgui.Plotting.Plottables module

Prototype plottable object support.

The main point of this prototype is to provide a clean separation between the style (plotter details: color, grids, widgets, etc.) and substance (application details: which information to plot). Programmers should not be dictating line colours and plotting symbols.

Unlike the problem of style in CSS or Word, where most paragraphs look the same, each line on a graph has to be distinguishable from its neighbours. Our solution is to provide parametric styles, in which a number of different classes of object (e.g., reflectometry data, reflectometry theory) representing multiple graph primitives cycle through a colour palette provided by the underlying plotter.

A full treatment would provide perceptual dimensions of prominence and distinctiveness rather than a simple colour number.

class sas.qtgui.Plotting.Plottables.Chisq(chisq=None)[source]

Bases: Plottable

Chisq plottable plots the chisq

__doc__ = '\n    Chisq plottable plots the chisq\n    '
__init__(chisq=None)[source]

Draw the chisq in plotter We can specify the position of chisq

__module__ = 'sas.qtgui.Plotting.Plottables'
render(plot, **kw)[source]
setChisq(chisq)[source]

Set the chisq value.

class sas.qtgui.Plotting.Plottables.Graph(**kw)[source]

Bases: object

Generic plottables graph structure.

Plot styles are based on color/symbol lists. The user gets to select the list of colors/symbols/sizes to choose from, not the application developer. The programmer only gets to add/remove lines from the plot and move to the next symbol/color.

Another dimension is prominence, which refers to line sizes/point sizes.

Axis transformations allow the user to select the coordinate view which provides clarity to the data. There is no way we can provide every possible transformation for every application generically, so the plottable objects themselves will need to provide the transformations. Here are some examples from reflectometry:

independent: x -> f(x)
   monitor scaling: y -> M*y
   log:  y -> log(y if y > min else min)
   cos:  y -> cos(y*pi/180)
dependent:   x -> f(x,y)
   Q4:      y -> y*x^4
   fresnel: y -> y*fresnel(x)
coordinated: x,y = f(x,y)
   Q:    x -> 2*pi/L (cos(x*pi/180) - cos(y*pi/180))
         y -> 2*pi/L (sin(x*pi/180) + sin(y*pi/180))
reducing: x,y = f(x1,x2,y1,y2)
   spin asymmetry: x -> x1, y -> (y1 - y2)/(y1 + y2)
   vector net: x -> x1, y -> y1*cos(y2*pi/180)

Multiple transformations are possible, such as Q4 spin asymmetry

Axes have further complications in that the units of what are being plotted should correspond to the units on the axes. Plotting multiple types on the same graph should be handled gracefully, e.g., by creating a separate tab for each available axis type, breaking into subplots, showing multiple axes on the same plot, or generating inset plots. Ultimately the decision should be left to the user.

Graph properties such as grids/crosshairs should be under user control, as should the sizes of items such as axis fonts, etc. No direct access will be provided to the application.

Axis limits are mostly under user control. If the user has zoomed or panned then those limits are preserved even if new data is plotted. The exception is when, e.g., scanning through a set of related lines in which the user may want to fix the limits so that user can compare the values directly. Another exception is when creating multiple graphs sharing the same limits, though this case may be important enough that it is handled by the graph widget itself. Axis limits will of course have to understand the effects of axis transformations.

High level plottable objects may be composed of low level primitives. Operations such as legend/hide/show copy/paste, etc. need to operate on these primitives as a group. E.g., allowing the user to have a working canvas where they can drag lines they want to save and annotate them.

Graphs need to be printable. A page layout program for entire plots would be nice.

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Plottables', '__doc__': '\n    Generic plottables graph structure.\n\n    Plot styles are based on color/symbol lists.  The user gets to select\n    the list of colors/symbols/sizes to choose from, not the application\n    developer.  The programmer only gets to add/remove lines from the\n    plot and move to the next symbol/color.\n\n    Another dimension is prominence, which refers to line sizes/point sizes.\n\n    Axis transformations allow the user to select the coordinate view\n    which provides clarity to the data.  There is no way we can provide\n    every possible transformation for every application generically, so\n    the plottable objects themselves will need to provide the transformations.\n    Here are some examples from reflectometry: ::\n\n       independent: x -> f(x)\n          monitor scaling: y -> M*y\n          log:  y -> log(y if y > min else min)\n          cos:  y -> cos(y*pi/180)\n       dependent:   x -> f(x,y)\n          Q4:      y -> y*x^4\n          fresnel: y -> y*fresnel(x)\n       coordinated: x,y = f(x,y)\n          Q:    x -> 2*pi/L (cos(x*pi/180) - cos(y*pi/180))\n                y -> 2*pi/L (sin(x*pi/180) + sin(y*pi/180))\n       reducing: x,y = f(x1,x2,y1,y2)\n          spin asymmetry: x -> x1, y -> (y1 - y2)/(y1 + y2)\n          vector net: x -> x1, y -> y1*cos(y2*pi/180)\n\n    Multiple transformations are possible, such as Q4 spin asymmetry\n\n    Axes have further complications in that the units of what are being\n    plotted should correspond to the units on the axes.  Plotting multiple\n    types on the same graph should be handled gracefully, e.g., by creating\n    a separate tab for each available axis type, breaking into subplots,\n    showing multiple axes on the same plot, or generating inset plots.\n    Ultimately the decision should be left to the user.\n\n    Graph properties such as grids/crosshairs should be under user control,\n    as should the sizes of items such as axis fonts, etc.  No direct\n    access will be provided to the application.\n\n    Axis limits are mostly under user control.  If the user has zoomed or\n    panned then those limits are preserved even if new data is plotted.\n    The exception is when, e.g., scanning through a set of related lines\n    in which the user may want to fix the limits so that user can compare\n    the values directly.  Another exception is when creating multiple\n    graphs sharing the same limits, though this case may be important\n    enough that it is handled by the graph widget itself.  Axis limits\n    will of course have to understand the effects of axis transformations.\n\n    High level plottable objects may be composed of low level primitives.\n    Operations such as legend/hide/show copy/paste, etc. need to operate\n    on these primitives as a group.  E.g., allowing the user to have a\n    working canvas where they can drag lines they want to save and annotate\n    them.\n\n    Graphs need to be printable.  A page layout program for entire plots\n    would be nice.\n\n    ', '_xaxis_transformed': <function Graph._xaxis_transformed>, '_yaxis_transformed': <function Graph._yaxis_transformed>, 'xaxis': <function Graph.xaxis>, 'yaxis': <function Graph.yaxis>, 'title': <function Graph.title>, 'get': <function Graph.get>, 'set': <function Graph.set>, 'isPlotted': <function Graph.isPlotted>, 'add': <function Graph.add>, 'changed': <function Graph.changed>, 'get_range': <function Graph.get_range>, 'replace': <function Graph.replace>, 'delete': <function Graph.delete>, 'reset_scale': <function Graph.reset_scale>, 'reset': <function Graph.reset>, '_make_labels': <function Graph._make_labels>, 'get_plottable': <function Graph.get_plottable>, 'returnPlottable': <function Graph.returnPlottable>, 'render': <function Graph.render>, '__init__': <function Graph.__init__>, '__dict__': <attribute '__dict__' of 'Graph' objects>, '__weakref__': <attribute '__weakref__' of 'Graph' objects>, '__annotations__': {}})
__doc__ = '\n    Generic plottables graph structure.\n\n    Plot styles are based on color/symbol lists.  The user gets to select\n    the list of colors/symbols/sizes to choose from, not the application\n    developer.  The programmer only gets to add/remove lines from the\n    plot and move to the next symbol/color.\n\n    Another dimension is prominence, which refers to line sizes/point sizes.\n\n    Axis transformations allow the user to select the coordinate view\n    which provides clarity to the data.  There is no way we can provide\n    every possible transformation for every application generically, so\n    the plottable objects themselves will need to provide the transformations.\n    Here are some examples from reflectometry: ::\n\n       independent: x -> f(x)\n          monitor scaling: y -> M*y\n          log:  y -> log(y if y > min else min)\n          cos:  y -> cos(y*pi/180)\n       dependent:   x -> f(x,y)\n          Q4:      y -> y*x^4\n          fresnel: y -> y*fresnel(x)\n       coordinated: x,y = f(x,y)\n          Q:    x -> 2*pi/L (cos(x*pi/180) - cos(y*pi/180))\n                y -> 2*pi/L (sin(x*pi/180) + sin(y*pi/180))\n       reducing: x,y = f(x1,x2,y1,y2)\n          spin asymmetry: x -> x1, y -> (y1 - y2)/(y1 + y2)\n          vector net: x -> x1, y -> y1*cos(y2*pi/180)\n\n    Multiple transformations are possible, such as Q4 spin asymmetry\n\n    Axes have further complications in that the units of what are being\n    plotted should correspond to the units on the axes.  Plotting multiple\n    types on the same graph should be handled gracefully, e.g., by creating\n    a separate tab for each available axis type, breaking into subplots,\n    showing multiple axes on the same plot, or generating inset plots.\n    Ultimately the decision should be left to the user.\n\n    Graph properties such as grids/crosshairs should be under user control,\n    as should the sizes of items such as axis fonts, etc.  No direct\n    access will be provided to the application.\n\n    Axis limits are mostly under user control.  If the user has zoomed or\n    panned then those limits are preserved even if new data is plotted.\n    The exception is when, e.g., scanning through a set of related lines\n    in which the user may want to fix the limits so that user can compare\n    the values directly.  Another exception is when creating multiple\n    graphs sharing the same limits, though this case may be important\n    enough that it is handled by the graph widget itself.  Axis limits\n    will of course have to understand the effects of axis transformations.\n\n    High level plottable objects may be composed of low level primitives.\n    Operations such as legend/hide/show copy/paste, etc. need to operate\n    on these primitives as a group.  E.g., allowing the user to have a\n    working canvas where they can drag lines they want to save and annotate\n    them.\n\n    Graphs need to be printable.  A page layout program for entire plots\n    would be nice.\n\n    '
__init__(**kw)[source]
__module__ = 'sas.qtgui.Plotting.Plottables'
__weakref__

list of weak references to the object

_make_labels()[source]
_xaxis_transformed(name, units)[source]

Change the property of the x axis according to an axis transformation (as opposed to changing the basic properties)

_yaxis_transformed(name, units)[source]

Change the property of the y axis according to an axis transformation (as opposed to changing the basic properties)

add(plottable, color=None)[source]

Add a new plottable to the graph

changed()[source]

Detect if any graphed plottables have changed

delete(plottable)[source]

Remove an existing plottable from the graph

get(key)[source]

Get the graph properties

get_plottable(name)[source]

Return the plottable with the given name if it exists. Otherwise return None

get_range()[source]

Return the range of all displayed plottables

isPlotted(plottable)[source]

Return True is the plottable is already on the graph

render(plot)[source]

Redraw the graph

replace(plottable)[source]

Replace an existing plottable from the graph

reset()[source]

Reset the graph.

reset_scale()[source]

Resets the scale transformation data to the underlying data

returnPlottable()[source]

This method returns a dictionary of plottables contained in graph It is just by Plotpanel to interact with the complete list of plottables inside the graph.

set(**kw)[source]

Set the graph properties

title(name)[source]

Graph title

xaxis(name, units)[source]

Properties of the x axis.

yaxis(name, units)[source]

Properties of the y axis.

class sas.qtgui.Plotting.Plottables.Plottable[source]

Bases: object

__annotations__ = {}
__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Plottables', '__doc__': '\n    ', 'short_name': None, 'name': None, 'x': None, 'y': None, 'dx': None, 'dy': None, 'hidden': False, 'interactive': True, 'custom_color': None, 'markersize': 3, 'show_yzero': False, '__init__': <function Plottable.__init__>, '__setattr__': <function Plottable.__setattr__>, 'set_data': <function Plottable.set_data>, 'xaxis': <function Plottable.xaxis>, 'yaxis': <function Plottable.yaxis>, 'get_xaxis': <function Plottable.get_xaxis>, 'get_yaxis': <function Plottable.get_yaxis>, 'labels': <classmethod(<function Plottable.labels>)>, 'setLabel': <function Plottable.setLabel>, 'set_View': <function Plottable.set_View>, 'reset_view': <function Plottable.reset_view>, 'render': <function Plottable.render>, 'is_empty': <function Plottable.is_empty>, 'colors': <function Plottable.colors>, 'transformView': <function Plottable.transformView>, 'returnValuesOfView': <function Plottable.returnValuesOfView>, 'check_data_PlottableX': <function Plottable.check_data_PlottableX>, 'check_data_PlottableY': <function Plottable.check_data_PlottableY>, 'transformX': <function Plottable.transformX>, 'transformY': <function Plottable.transformY>, 'onReset': <function Plottable.onReset>, 'onFitRange': <function Plottable.onFitRange>, '__dict__': <attribute '__dict__' of 'Plottable' objects>, '__weakref__': <attribute '__weakref__' of 'Plottable' objects>, '__annotations__': {}})
__doc__ = '\n    '
__init__()[source]
__module__ = 'sas.qtgui.Plotting.Plottables'
__setattr__(name, value)[source]

Take care of changes in View when data is changed. This method is provided for backward compatibility.

__weakref__

list of weak references to the object

check_data_PlottableX()[source]

Since no transformation is made for log10(x), check that no negative values is plot in log scale

check_data_PlottableY()[source]

Since no transformation is made for log10(y), check that no negative values is plot in log scale

colors()[source]

Return the number of colors need to render the object

custom_color = None
dx = None
dy = None
get_xaxis()[source]

Return the units and name of x-axis

get_yaxis()[source]

Return the units and name of y- axis

hidden = False
interactive = True
is_empty()[source]

Returns True if there is no data stored in the plottable

classmethod labels(collection)[source]

Construct a set of unique labels for a collection of plottables of the same type.

Returns a map from plottable to name.

markersize = 3
name = None
onFitRange(xmin=None, xmax=None)[source]

It limits View data range to plot from min to max

Parameters:
  • xmin – the minimum value of x to plot.

  • xmax – the maximum value of x to plot

onReset()[source]

Reset x, y, dx, dy view with its parameters

render(plot)[source]

The base class makes sure the correct units are being used for subsequent plottable.

For now it is assumed that the graphs are commensurate, and if you put a Qx object on a Temperature graph then you had better hope that it makes sense.

reset_view()[source]

Reload view with new value to plot

returnValuesOfView()[source]

Return View parameters and it is used by Fit Dialog

setLabel(labelx, labely)[source]

It takes a label of the x and y transformation and set View parameters

Parameters:
  • transx – The label of x transformation is sent by Properties Dialog

  • transy – The label of y transformation is sent Properties Dialog

set_View(x, y)[source]

Load View

set_data(x, y, dx=None, dy=None)[source]
short_name = None
show_yzero = False
transformView()[source]

It transforms x, y before displaying

transformX(transx, transdx)[source]

Receive pointers to function that transform x and dx and set corresponding View pointers

Parameters:
  • transx – pointer to function that transforms x

  • transdx – pointer to function that transforms dx

transformY(transy, transdy)[source]

Receive pointers to function that transform y and dy and set corresponding View pointers

Parameters:
  • transy – pointer to function that transforms y

  • transdy – pointer to function that transforms dy

x = None
xaxis(name, units)[source]

Set the name and unit of x_axis

Parameters:
  • name – the name of x-axis

  • units – the units of x_axis

y = None
yaxis(name, units)[source]

Set the name and unit of y_axis

Parameters:
  • name – the name of y-axis

  • units – the units of y_axis

class sas.qtgui.Plotting.Plottables.PlottableData1D(x, y, dx=None, dy=None)[source]

Bases: Plottable

Data plottable: scatter plot of x,y with errors in x and y.

__annotations__ = {}
__doc__ = '\n    Data plottable: scatter plot of x,y with errors in x and y.\n    '
__init__(x, y, dx=None, dy=None)[source]

Draw points specified by x[i],y[i] in the current color/symbol. Uncertainty in x is given by dx[i], or by (xlo[i],xhi[i]) if the uncertainty is asymmetric. Similarly for y uncertainty.

The title appears on the legend. The label, if it is different, appears on the status bar.

__module__ = 'sas.qtgui.Plotting.Plottables'
changed()[source]
classmethod labels(collection)[source]

Build a label mostly unique within a collection

render(plot, **kw)[source]

Renders the plottable on the graph

class sas.qtgui.Plotting.Plottables.PlottableData2D(image=None, qx_data=None, qy_data=None, err_image=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None)[source]

Bases: Plottable

2D data class for image plotting

__annotations__ = {}
__doc__ = '\n    2D data class for image plotting\n    '
__init__(image=None, qx_data=None, qy_data=None, err_image=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None)[source]

Draw image

__module__ = 'sas.qtgui.Plotting.Plottables'
changed()[source]
classmethod labels(collection)[source]

Build a label mostly unique within a collection

render(plot, **kw)[source]

Renders the plottable on the graph

setValues(datainfo=None)[source]

Use datainfo object to initialize data2D

Parameters:

datainfo – object

set_zrange(zmin=None, zmax=None)[source]
xaxis(label, unit)[source]

set x-axis

Parameters:
  • label – x-axis label

  • unit – x-axis unit

yaxis(label, unit)[source]

set y-axis

Parameters:
  • label – y-axis label

  • unit – y-axis unit

zaxis(label, unit)[source]

set z-axis

Parameters:
  • label – z-axis label

  • unit – z-axis unit

class sas.qtgui.Plotting.Plottables.PlottableFit1D(data=None, theory=None)[source]

Bases: Plottable

Fit plottable: composed of a data line plus a theory line. This is treated like a single object from the perspective of the graph, except that it will have two legend entries, one for the data and one for the theory.

The color of the data and theory will be shared.

__annotations__ = {}
__doc__ = '\n    Fit plottable: composed of a data line plus a theory line.  This\n    is treated like a single object from the perspective of the graph,\n    except that it will have two legend entries, one for the data and\n    one for the theory.\n\n    The color of the data and theory will be shared.\n\n    '
__init__(data=None, theory=None)[source]
__module__ = 'sas.qtgui.Plotting.Plottables'
changed()[source]
render(plot, **kw)[source]
class sas.qtgui.Plotting.Plottables.PlottableTheory1D(x, y, dy=None)[source]

Bases: Plottable

Theory plottable: line plot of x,y with confidence interval y.

__annotations__ = {}
__doc__ = '\n    Theory plottable: line plot of x,y with confidence interval y.\n    '
__init__(x, y, dy=None)[source]

Draw lines specified in x[i],y[i] in the current color/symbol. Confidence intervals in x are given by dx[i] or by (xlo[i],xhi[i]) if the limits are asymmetric.

The title is the name that will show up on the legend.

__module__ = 'sas.qtgui.Plotting.Plottables'
class sas.qtgui.Plotting.Plottables.Text(text=None, xpos=0.5, ypos=0.9, name='text')[source]

Bases: Plottable

__annotations__ = {}
__doc__ = '\n    '
__init__(text=None, xpos=0.5, ypos=0.9, name='text')[source]

Draw the user-defined text in plotter We can specify the position of text

__module__ = 'sas.qtgui.Plotting.Plottables'
getText(text)[source]

Get the text string.

render(plot, **kw)[source]
setText(text)[source]

Set the text string.

set_x(x)[source]

Set the x position of the text ACCEPTS: float

set_y(y)[source]

Set the y position of the text ACCEPTS: float

class sas.qtgui.Plotting.Plottables.Transform[source]

Bases: object

Define a transform plugin to the plottable architecture.

Transforms operate on axes. The plottable defines the set of transforms available for it, and the axes on which they operate. These transforms can operate on the x axis only, the y axis only or on the x and y axes together.

This infrastructure is not able to support transformations such as log and polar plots as these require full control over the drawing of axes and grids.

A transform has a number of attributes.

name

user visible name for the transform. This will appear in the context menu for the axis and the transform menu for the graph.

type

operational axis. This determines whether the transform should appear on x,y or z axis context menus, or if it should appear in the context menu for the graph.

inventory

(not implemented) a dictionary of user settable parameter names and their associated types. These should appear as keyword arguments to the transform call. For example, Fresnel reflectivity requires the substrate density: { 'rho': type.Value(10e-6/units.angstrom**2) } Supply reasonable defaults in the callback so that limited plotting clients work even though they cannot set the inventory.

__call__(plottable, **kwargs)[source]

Transform the data. Whenever a plottable is added to the axes, the infrastructure will apply all required transforms. When the user selects a different representation for the axes (via menu, script, or context menu), all plottables on the axes will be transformed. The plottable should store the underlying data but set the standard x,dx,y,dy,z,dz attributes appropriately.

If the call raises a NotImplemented error the dataline will not be plotted. The associated string will usually be ‘Not a valid transform’, though other strings are possible. The application may or may not display the message to the user, along with an indication of which plottable was at fault.

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Plottables', '__doc__': "\n    Define a transform plugin to the plottable architecture.\n\n    Transforms operate on axes.  The plottable defines the\n    set of transforms available for it, and the axes on which\n    they operate.  These transforms can operate on the x axis\n    only, the y axis only or on the x and y axes together.\n\n    This infrastructure is not able to support transformations\n    such as log and polar plots as these require full control\n    over the drawing of axes and grids.\n\n    A transform has a number of attributes.\n\n    name\n      user visible name for the transform.  This will\n      appear in the context menu for the axis and the transform\n      menu for the graph.\n\n    type\n      operational axis.  This determines whether the\n      transform should appear on x,y or z axis context\n      menus, or if it should appear in the context menu for\n      the graph.\n\n    inventory\n      (not implemented)\n      a dictionary of user settable parameter names and\n      their associated types.  These should appear as keyword\n      arguments to the transform call.  For example, Fresnel\n      reflectivity requires the substrate density:\n      ``{ 'rho': type.Value(10e-6/units.angstrom**2) }``\n      Supply reasonable defaults in the callback so that\n      limited plotting clients work even though they cannot\n      set the inventory.\n\n    ", '__call__': <function Transform.__call__>, '__dict__': <attribute '__dict__' of 'Transform' objects>, '__weakref__': <attribute '__weakref__' of 'Transform' objects>, '__annotations__': {}})
__doc__ = "\n    Define a transform plugin to the plottable architecture.\n\n    Transforms operate on axes.  The plottable defines the\n    set of transforms available for it, and the axes on which\n    they operate.  These transforms can operate on the x axis\n    only, the y axis only or on the x and y axes together.\n\n    This infrastructure is not able to support transformations\n    such as log and polar plots as these require full control\n    over the drawing of axes and grids.\n\n    A transform has a number of attributes.\n\n    name\n      user visible name for the transform.  This will\n      appear in the context menu for the axis and the transform\n      menu for the graph.\n\n    type\n      operational axis.  This determines whether the\n      transform should appear on x,y or z axis context\n      menus, or if it should appear in the context menu for\n      the graph.\n\n    inventory\n      (not implemented)\n      a dictionary of user settable parameter names and\n      their associated types.  These should appear as keyword\n      arguments to the transform call.  For example, Fresnel\n      reflectivity requires the substrate density:\n      ``{ 'rho': type.Value(10e-6/units.angstrom**2) }``\n      Supply reasonable defaults in the callback so that\n      limited plotting clients work even though they cannot\n      set the inventory.\n\n    "
__module__ = 'sas.qtgui.Plotting.Plottables'
__weakref__

list of weak references to the object

class sas.qtgui.Plotting.Plottables.View(x=None, y=None, dx=None, dy=None)[source]

Bases: object

Representation of the data that might include a transformation

__dict__ = mappingproxy({'__module__': 'sas.qtgui.Plotting.Plottables', '__doc__': '\n    Representation of the data that might include a transformation\n    ', 'x': None, 'y': None, 'dx': None, 'dy': None, '__init__': <function View.__init__>, 'transform': <function View.transform>, 'onResetView': <function View.onResetView>, 'setTransformX': <function View.setTransformX>, 'setTransformY': <function View.setTransformY>, 'returnXview': <function View.returnXview>, 'check_data_logX': <function View.check_data_logX>, 'check_data_logY': <function View.check_data_logY>, 'onFitRangeView': <function View.onFitRangeView>, '__dict__': <attribute '__dict__' of 'View' objects>, '__weakref__': <attribute '__weakref__' of 'View' objects>, '__annotations__': {}})
__doc__ = '\n    Representation of the data that might include a transformation\n    '
__init__(x=None, y=None, dx=None, dy=None)[source]
__module__ = 'sas.qtgui.Plotting.Plottables'
__weakref__

list of weak references to the object

check_data_logX()[source]

Remove negative value in x vector to avoid plotting negative value of Log10

check_data_logY()[source]

Remove negative value in y vector to avoid plotting negative value of Log10

dx = None
dy = None
onFitRangeView(xmin=None, xmax=None)[source]

It limits View data range to plot from min to max

Parameters:
  • xmin – the minimum value of x to plot.

  • xmax – the maximum value of x to plot

onResetView()[source]

Reset x,y,dx and y in their full range and in the initial scale in case their previous range has changed

returnXview()[source]

Return View x,y,dx,dy

setTransformX(funcx, funcdx)[source]

Receive pointers to function that transform x and dx and set corresponding View pointers

Parameters:
  • transx – pointer to function that transforms x

  • transdx – pointer to function that transforms dx

setTransformY(funcy, funcdy)[source]

Receive pointers to function that transform y and dy and set corresponding View pointers

Parameters:
  • transx – pointer to function that transforms y

  • transdx – pointer to function that transforms dy

transform(x=None, y=None, dx=None, dy=None)[source]
Transforms the x,y,dx and dy vectors and stores

the output in View parameters

Parameters:
  • x – array of x values

  • y – array of y values

  • dx – array of errors values on x

  • dy – array of error values on y

x = None
y = None
sas.qtgui.Plotting.Plottables.all(L)[source]
sas.qtgui.Plotting.Plottables.any(L)[source]

sas.qtgui.Plotting.Plotter module

sas.qtgui.Plotting.Plotter2D module

sas.qtgui.Plotting.PlotterBase module

sas.qtgui.Plotting.PlotterData module

Adapters for fitting module

class sas.qtgui.Plotting.PlotterData.Data1D(x=None, y=None, dx=None, dy=None)[source]

Bases: PlottableData1D, Data1D

ROLE_DATA = 0
ROLE_DEFAULT = 1
ROLE_DELETABLE = 2
ROLE_RESIDUAL = 3
__annotations__ = {}
__doc__ = '\n    '
__init__(x=None, y=None, dx=None, dy=None)[source]
__module__ = 'sas.qtgui.Plotting.PlotterData'
__str__()[source]

print data

_perform_operation(other, operation)[source]
_perform_union(other)[source]
copy_from_datainfo(data1d)[source]

copy values of Data1D of type DataLaoder.Data_info

class sas.qtgui.Plotting.PlotterData.Data2D(image=None, err_image=None, qx_data=None, qy_data=None, q_data=None, mask=None, dqx_data=None, dqy_data=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None)[source]

Bases: PlottableData2D, Data2D

__annotations__ = {}
__doc__ = '\n    '
__init__(image=None, err_image=None, qx_data=None, qy_data=None, q_data=None, mask=None, dqx_data=None, dqy_data=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None)[source]
__module__ = 'sas.qtgui.Plotting.PlotterData'
__str__()[source]

print data

_perform_operation(other, operation)[source]

Perform 2D operations between data sets

Parameters:
  • other – other data set

  • operation – function defining the operation

_perform_union(other)[source]

Perform 2D operations between data sets

Parameters:
  • other – other data set

  • operation – function defining the operation

copy_from_datainfo(data2d)[source]

copy value of Data2D of type DataLoader.data_info

sas.qtgui.Plotting.PlotterData.check_data_validity(data)[source]

Return True is data is valid enough to compute chisqr, else False

sas.qtgui.Plotting.QRangeSlider module

Double slider interactor for setting the Q range for a fit or function

class sas.qtgui.Plotting.QRangeSlider.LineInteractor(base: Plotter, axes: Plotter.ax, color: str = 'black', zorder: int = 5, x: float = 0.5, y: float = 0.5, input: [str] = None, setter: [str] = None, getter: [str] = None, perspective: str = None, tab: str = None)[source]

Bases: BaseInteractor

Draw a single vertical line that can be dragged on a plot

__doc__ = '\n    Draw a single vertical line that can be dragged on a plot\n    '
__init__(base: Plotter, axes: Plotter.ax, color: str = 'black', zorder: int = 5, x: float = 0.5, y: float = 0.5, input: [str] = None, setter: [str] = None, getter: [str] = None, perspective: str = None, tab: str = None) None[source]

Initialize the line interactor object

__module__ = 'sas.qtgui.Plotting.QRangeSlider'
_get_input_or_callback(connection_list: [<class 'str'>] = None) QLineEdit | QTextEdit | None[source]

Returns an input or callback method based on a list of inputs/commands

_get_q() None[source]

Get the q value, inferring the method to get the value

_set_q(value: float) None[source]

Call the q setter callback method if it exists

clear() None[source]

Disconnect any inputs and callbacks and the clear the line and marker

clear_markers() None[source]

Disconnect the input and clear the callbacks

draw(zorder: int = 5) None[source]

Draw the line and marker on the linked plot using the latest x and y values

property getter: callable | None

Get the x-value getter method associated with this slider

property input: QLineEdit | QTextEdit | None

Get the text input that should be linked to the position of this slider

inputChanged() None[source]

Track the input linked to the x value for this slider and update as needed

move(x: float, y: float, ev: QEvent) None[source]

Process move to a new position, making sure that the move is allowed.

onRelease(ev: QEvent) bool[source]

Update the line position when the mouse button is released

remove() None[source]

Clear this slicer and its markers

restore(ev: QEvent) None[source]

Restore the position for this line

save(ev: QEvent) None[source]

Remember the position for this line so that we can restore on Esc.

property setter: callable | None

Get the x-value setter method associated with this slider

update(x: float = None, y: float = None, draw: bool = False) None[source]

Update the line position on the graph.

class sas.qtgui.Plotting.QRangeSlider.QRangeSlider(base: Plotter, axes: Plotter.ax, color: str = 'black', zorder: int = 5, data: Data1D = None)[source]

Bases: BaseInteractor

Draw a pair of draggable vertical lines. Each line can be linked to a GUI input. The GUI input should update the lines and vice-versa.

__annotations__ = {}
__doc__ = '  Draw a pair of draggable vertical lines. Each line can be linked to a GUI input.\n    The GUI input should update the lines and vice-versa.\n    '
__init__(base: Plotter, axes: Plotter.ax, color: str = 'black', zorder: int = 5, data: Data1D = None) None[source]

Initialize the slideable lines and associated markers

__module__ = 'sas.qtgui.Plotting.QRangeSlider'
clear() None[source]

Clear this slicer and its markers

clear_markers() None[source]

Clear each of the lines individually

draw() None[source]

Update the plot

move(x: float, y: float, ev: QEvent) None[source]

Process move to a new position, making sure that the move is allowed.

remove() None[source]

Remove this slicer and its markers

restore(ev: QEvent) None[source]

Restore the lines.

save(ev: QEvent) None[source]

Remember the position of the lines so that we can restore on Esc.

show() None[source]

Show this slicer and its markers

toggle() None[source]

Toggle the slider visibility.

update(x: float = None, y: float = None) None[source]

Draw the new lines on the graph.

sas.qtgui.Plotting.ScaleProperties module

class sas.qtgui.Plotting.ScaleProperties.ScaleProperties(parent=None, init_scale_x='x', init_scale_y='y')[source]

Bases: QDialog, Ui_scalePropertiesUI

__annotations__ = {}
__doc__ = None
__init__(parent=None, init_scale_x='x', init_scale_y='y')[source]
__module__ = 'sas.qtgui.Plotting.ScaleProperties'
getValues()[source]

Return current values from comboboxes

viewIndexChanged(index)[source]

Update X and Y labels based on the “View” index

xyIndexChanged(index)[source]

Update View label based on the “X” and “Y” index

sas.qtgui.Plotting.SetGraphRange module

sas.qtgui.Plotting.SlicerModel module

sas.qtgui.Plotting.SlicerParameters module

sas.qtgui.Plotting.WindowTitle module

Allows users to change the title of the current graph from “Graph_n” to any ASCII text.

class sas.qtgui.Plotting.WindowTitle.WindowTitle(parent=None, new_title='')[source]

Bases: QDialog, Ui_WindowTitle

Simple GUI for a single line text query

__annotations__ = {}
__doc__ = ' Simple GUI for a single line text query '
__init__(parent=None, new_title='')[source]
__module__ = 'sas.qtgui.Plotting.WindowTitle'
title()[source]

Return the new title

sas.qtgui.Plotting.rangeSlider module

class sas.qtgui.Plotting.rangeSlider.RangeSlider(*args)[source]

Bases: QSlider

A slider for ranges.

This class provides a dual-slider for ranges, where there is a defined maximum and minimum, as is a normal slider, but instead of having a single slider value, there are 2 slider values.

This class emits the same signals as the QSlider base class, with the exception of valueChanged.

In addition, two new signals are emitted to catch the movement of each handle, lowValueChanged(int) and highValueChanged(int).

__annotations__ = {}
__doc__ = ' A slider for ranges.\n    \n        This class provides a dual-slider for ranges, where there is a defined\n        maximum and minimum, as is a normal slider, but instead of having a\n        single slider value, there are 2 slider values.\n        \n        This class emits the same signals as the QSlider base class, with the \n        exception of valueChanged. \n\n        In addition, two new signals are emitted to catch the movement of \n        each handle, lowValueChanged(int) and highValueChanged(int).\n    '
__init__(*args)[source]
__module__ = 'sas.qtgui.Plotting.rangeSlider'
__pick(pt)
__pixelPosToRangeValue(pos)
highValue()[source]
highValueChanged

pyqtSignal(*types, name: str = …, revision: int = …, arguments: Sequence = …) -> PYQT_SIGNAL

types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal’s arguments.

lowValue()[source]
lowValueChanged

pyqtSignal(*types, name: str = …, revision: int = …, arguments: Sequence = …) -> PYQT_SIGNAL

types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal’s arguments.

mouseMoveEvent(self, ev: QMouseEvent | None)[source]
mousePressEvent(self, ev: QMouseEvent | None)[source]
mouseReleaseEvent(self, ev: QMouseEvent | None)[source]
paintEvent(self, ev: QPaintEvent | None)[source]
setHighValue(high)[source]
setLowValue(low)[source]

Module contents