-                      r82a54b8
+                      r10bfeb3
 import copy
 import numpy
-import math
 import sys
 …
     def any(L):
         for cond in L:
+            if cond: return True
+            if cond:
+                return True
         return False
     def all(L):
         for cond in L:
 …
         return True
+# Graph structure for holding multiple plottables
 class Graph:
     """
 …
         (as opposed to changing the basic properties)
         """
         if units != "":
              name = "%s (%s)" % (name, units)
+        if units != "":
+            name = "%s (%s)" % (name, units)
         self.prop["xlabel"] = name
         self.prop["xunit"] = units
 …
         (as opposed to changing the basic properties)
         """
         if units != "":
              name = "%s (%s)" % (name, units)
+        if units != "":
+            name = "%s (%s)" % (name, units)
         self.prop["ylabel"] = name
         self.prop["yunit"] = units
 …
         Properties of the x axis.
         """
         if units != "":
              name = "%s (%s)" % (name, units)
+        if units != "":
+            name = "%s (%s)" % (name, units)
         self.prop["xlabel"] = name
         self.prop["xunit"] = units
 …
         Properties of the y axis.
         """
         if units != "":
              name = "%s (%s)" % (name, units)
+        if units != "":
+            name = "%s (%s)" % (name, units)
         self.prop["ylabel"] = name
         self.prop["yunit"] = units
 …
         if plottable in self.plottables:
             return True
         return False
+        return False
     def add(self, plottable, color=None):
 …
                 self.color += plottable.colors()
                 self.plottables[plottable] = self.color
     def changed(self):
         """Detect if any graphed plottables have changed"""
 …
         if plottable in self.plottables:
             del self.plottables[plottable]
             self.color = len(self.plottables)
+            self.color = len(self.plottables)
     def reset_scale(self):
 …
         self.color = -1
         self.symbol = 0
         self.prop = {"xlabel":"", "xunit":None,
                      "ylabel":"","yunit":None,
                      "title":""}
+        self.prop = {"xlabel": "", "xunit": None,
+                     "ylabel": "", "yunit": None,
+                     "title": ""}
         self.plottables = {}
 …
         """
         This method returns a dictionary of plottables contained in graph
         It is just by Plotpanel to interact with the complete list of plottables
+        It is just by Plotpanel to interact with the complete list of plottables
         inside the graph.
         """
 …
         for p in self.plottables:
             if p.custom_color is not None:
                 p.render(plot, color=p.custom_color, symbol=0,
+                p.render(plot, color=p.custom_color, symbol=0,
                 markersize=p.markersize, label=labels[p])
             else:
                 p.render(plot, color=self.plottables[p], symbol=0,
+                p.render(plot, color=self.plottables[p], symbol=0,
                      markersize=p.markersize, label=labels[p])
         plot.render()
 …
         menu for the graph.
     type: operational axis.  This determines whether the
+    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
 …
     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
+        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
+        Supply reasonable defaults in the callback so that
+        limited plotting clients work even though they cannot
         set the inventory.
 …
         the standard x,dx,y,dy,z,dz attributes appropriately.
         If the call raises a NotImplemented error the dataline
+        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.
 …
         """
         raise NotImplemented,"Not a valid transform"
+        raise NotImplemented, "Not a valid transform"
     # Related issues
 …
     # log scale:
     #    All axes have implicit log/linear scaling options.
+    #
+    #
     # normalization:
     #    Want to display raw counts vs detector efficiency correction
 …
+    #
     # multiline graph:
     #    How do we show/hide data parts.  E.g., data or theory, or
+    #    How do we show/hide data parts.  E.g., data or theory, or
     #    different polarization cross sections?  One way is with
     #    tags: each plottable has a set of tags and the tags are
 …
     """
     """
     # Short ascii name to refer to the plottable in a menu
+    # Short ascii name to refer to the plottable in a menu
     short_name = None
     # Fancy name
 …
     interactive = True
     custom_color = None
     markersize = 5 #default marker size is 'size 5'
+    markersize = 5  # default marker size is 'size 5'
     def __init__(self):
 …
         self._xunit = ""
         self._yaxis = ""
         self._yunit = ""
+        self._yunit = ""
     def __setattr__(self, name, value):
 …
     def labels(cls, collection):
         """
         Construct a set of unique labels for a collection of plottables of
+        Construct a set of unique labels for a collection of plottables of
         the same type.
 …
             else:
                 for i in xrange(len(collection)):
                     map[collection[i]] = "%s %d"%(basename, i)
+                    map[collection[i]] = "%s %d" % (basename, i)
         return map
     ##Use the following if @classmethod doesn't work
     # labels = classmethod(labels)
 …
     def set_View(self, x, y):
         """Load View"""
         self.x= x
+        self.x = x
         self.y = y
         self.reset_view()
 …
         """
         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
+        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.
 …
         return False
     def colors(self):
         """Return the number of colors need to render the object"""
 …
         return self.view.returnXview()
     def check_data_PlottableX(self):
         """
         Since no transformation is made for log10(x), check that
+    def check_data_PlottableX(self):
+        """
+        Since no transformation is made for log10(x), check that
         no negative values is plot in log scale
         """
         self.view.check_data_logX()
     def check_data_PlottableY(self):
+    def check_data_PlottableY(self):
         """
         Since no transformation is made for log10(y), check that
         no negative values is plot in log scale
         """
         self.view.check_data_logY()
+        self.view.check_data_logY()
     def transformX(self, transx, transdx):
         """
         Receive pointers to function that transform x and dx
+        Receive pointers to function that transform x and dx
         and set corresponding View pointers
 …
     def transformY(self, transy, transdy):
         """
         Receive pointers to function that transform y and dy
+        Receive pointers to function that transform y and dy
         and set corresponding View pointers
 …
         """
         self.view.onFitRangeView(xmin, xmax)
 class View:
     """
 …
         :param x: array of x values
         :param y: array of y values
         :param dx: array of  errors values on x
+        :param dx: array of  errors values on x
         :param dy: array of error values on y
 …
         has_err_y = not (dy == None or len(dy) == 0)
         if(x != None) and (y != None):
             if not dx == None and not len(dx) == 0 and not len(x)== len(dx):
+        if(x != None) and (y != None):
+            if not dx == None and not len(dx) == 0 and not len(x) == len(dx):
                 msg = "Plottable.View: Given x and dx are not"
                 msg += " of the same length"
+                msg += " of the same length"
                 raise ValueError, msg
             # Check length of y array
 …
                 raise ValueError, msg
             if not dy == None and not len(dy) == 0 and not len(y)==len(dy):
+            if not dy == None and not len(dy) == 0 and not len(y) == len(dy):
                 msg = "Plottable.View: Given y and dy are not of the same "
                 msg += "length: len(y)=%s, len(dy)=%s" %(len(y),len(dy))
+                msg += "length: len(y)=%s, len(dy)=%s" % (len(y), len(dy))
                 raise ValueError, msg
             self.x = []
 …
             for i in range(len(x)):
                 try:
                     tempx =self.funcx(x[i],y[i])
                     tempy =self.funcy(y[i],x[i])
+                    tempx = self.funcx(x[i], y[i])
+                    tempy = self.funcy(y[i], x[i])
                     if has_err_x:
                         tempdx = self.funcdx(x[i], y[i], dx[i], dy[i])
 …
             if not len(self.x) == len(self.y):
                 msg = "Plottable.View: transformed x "
                 msg += "and y are not of the same length"
+                msg += "and y are not of the same length"
                 raise ValueError, msg
             if has_err_x and not (len(self.x) and len(self.dx)):
                 msg = "Plottable.View: transformed x and dx"
                 msg += " are not of the same length"
+                msg += " are not of the same length"
                 raise ValueError, msg
             if has_err_y and not (len(self.y) and len(self.dy)):
                 msg = "Plottable.View: transformed y"
                 msg += " and dy are not of the same length"
+                msg += " and dy are not of the same length"
                 raise ValueError, msg
             # Check that negative values are not plot on x and y axis for
 …
         """
         Reset x,y,dx and y in their full range  and in the initial scale
+        in case their previous range has changed
+        in case their previous range has changed
         """
         self.x = self.Xreel
 …
         self.dy = self.DYreel
     def setTransformX(self, funcx, funcdx):
         """
         Receive pointers to function that transform x and dx
+    def setTransformX(self, funcx, funcdx):
+        """
+        Receive pointers to function that transform x and dx
         and set corresponding View pointers
         :param transx: pointer to function that transforms x
         :param transdx: pointer to function that transforms dx
         """
         self.funcx = funcx
 …
     def setTransformY(self, funcy, funcdy):
         """
         Receive pointers to function that transform y and dy
+        Receive pointers to function that transform y and dy
         and set corresponding View pointers
         :param transx: pointer to function that transforms y
         :param transdx: pointer to function that transforms dy
+        """
+        """
         self.funcy = funcy
         self.funcdy = funcdy
 …
         return self.x, self.y, self.dx, self.dy
     def check_data_logX(self):
+    def check_data_logX(self):
         """
         Remove negative value in x vector to avoid plotting negative
         value of Log10
         """
         tempx = []
 …
         if self.dy == None:
             self.dy = numpy.zeros(len(self.y))
         if self.xLabel == "log10(x)" :
+        if self.xLabel == "log10(x)":
             for i in range(len(self.x)):
                 try:
 …
                 except:
                     print "check_data_logX: skipping point x %g" % self.x[i]
                     print sys.exc_value
+                    print sys.exc_value
                     pass
             self.x = tempx
 …
             self.dy = tempdy
     def check_data_logY(self):
         """
         Remove negative value in y vector
+    def check_data_logY(self):
+        """
+        Remove negative value in y vector
         to avoid plotting negative value of Log10
 …
         if self.dy == None:
             self.dy = numpy.zeros(len(self.y))
         if (self.yLabel == "log10(y)" ):
+        if (self.yLabel == "log10(y)"):
             for i in range(len(self.x)):
                  try:
+                try:
                     if (self.y[i] > 0):
                         tempx.append(self.x[i])
 …
                         tempy.append(self.y[i])
                         tempdy.append(self.dy[i])
                  except:
                     print "check_data_logY: skipping point %g" %self.y[i]
                     print sys.exc_value
+                except:
+                    print "check_data_logY: skipping point %g" % self.y[i]
+                    print sys.exc_value
                     pass
             self.x = tempx
 …
             self.dx = numpy.zeros(len(self.x))
         if self.dy == None:
             self.dy=numpy.zeros(len(self.y))
+            self.dy = numpy.zeros(len(self.y))
         if (xmin != None) and (xmax != None):
             for i in range(len(self.x)):
 …
             self.y = tempy
             self.dx = tempdx
+            self.dy = tempdy
+            self.dy = tempdy
 class Data2D(Plottable):
     """
 …
         self._yunit = 'A^{-1}'
         ### might remove that later
+        ### might remove that later
         ## Vector of Q-values at the center of each bin in x
         self.x_bins = []
 …
         plot.image(self.data, self.qx_data, self.qy_data,
                    self.xmin, self.xmax, self.ymin,
                    self.ymax, self.zmin, self.zmax, **kw)
+                   self.ymax, self.zmin, self.zmax, **kw)
     def changed(self):
 …
             map[item] = item.label
         return map
 class Data1D(Plottable):
 …
         if self.interactive == True:
             kw['symbol'] = self.symbol
             kw['id'] =  self.id
+            kw['id'] = self.id
             kw['hide_error'] = self.hide_error
             kw['markersize'] = self.markersize
             plot.interactive_points(self.view.x, self.view.y,
                                     dx=self.view.dx, dy=self.view.dy,
               name=self.name, **kw)
+              name=self.name, **kw)
         else:
             kw['id'] =  self.id
 …
             kw['color'] = self.custom_color
             kw['markersize'] = self.markersize
             plot.points(self.view.x, self.view.y, dx=self.view.dx,
+            plot.points(self.view.x, self.view.y, dx=self.view.dx,
                 dy=self.view.dy, marker=self.symbollist[self.symbol], **kw)
 …
             map[item] = item.label
         return map
 class Theory1D(Plottable):
 …
         """
         """
+        if self.interactive==True:
+            kw['id'] =  self.id
+        if self.interactive == True:
+            kw['id'] = self.id
             plot.interactive_curve(self.view.x, self.view.y,
                                    dy=self.view.dy,
                                    name=self.name, **kw)
         else:
             kw['id'] =  self.id
+            kw['id'] = self.id
             plot.curve(self.view.x, self.view.y, dy=self.view.dy, **kw)
 …
         map = {}
         for item in collection:
-            #map[item] = label(item, collection)
-            #map[item] = r"$\rm{%s}$" % item.name
             if item.label == "theory":
                 item.label = item.name
 …
         return self.data.changed() or self.theory.changed()
 # ---------------------------------------------------------------
 class Text(Plottable):
 …
         self.ypos = ypos
     def render(self,plot,**kw):
+    def render(self, plot, **kw):
         """
         """
         from matplotlib import transforms
         xcoords=transforms.blended_transform_factory(plot.subplot.transAxes,
                                                      plot.subplot.transAxes)
+        xcoords = transforms.blended_transform_factory(plot.subplot.transAxes,
+                                                       plot.subplot.transAxes)
         plot.subplot.text(self.xpos,
                           self.ypos,
 …
     def setText(self, text):
         """Set the text string."""
         self.text =  text
+        self.text = text
     def getText(self, text):
 …
 class Chisq(Plottable):
     """
     Chisq plottable plots the chisq
+    Chisq plottable plots the chisq
     """
     def __init__(self, chisq=None):
 …
         Set the chisq value.
         """
         self._chisq =  chisq
+        self._chisq = chisq
 …
     # Construct a simple graph
     if False:
         x = nx.array([1,2,3,4,5,6],'d')
         y = nx.array([4,5,6,5,4,5],'d')
+        x = nx.array([1,2,3,4,5,6], 'd')
+        y = nx.array([4,5,6,5,4,5], 'd')
         dy = nx.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3])
     else:
         x = nx.linspace(0,1.,10000)
+        x = nx.linspace(0, 1., 10000)
         y = nx.sin(2 * nx.pi * x * 2.8)
         dy = nx.sqrt(100 * nx.abs(y)) / 100
 …
     graph.add(data)
     graph.add(Theory1D(x, y, dy=dy))
+    return graph
+    return graph
 def demo_plotter(graph):
 …
     class GraphUpdate:
+        callnum=0
+        callnum = 0
         def __init__(self, graph, plotter):
             self.graph, self.plotter = graph, plotter
         def __call__(self):
             if self.graph.changed():
+            if self.graph.changed():
                 self.graph.render(self.plotter)
                 return True
             return False
         def onIdle(self, event):
-            #print "On Idle checker %d"%(self.callnum)
             self.callnum = self.callnum + 1
             if self.__call__():
                 pass # event.RequestMore()
+                pass  # event.RequestMore()
     update = GraphUpdate(graph, plotter)
     frame.Bind(wx.EVT_IDLE, update.onIdle)
     app.MainLoop()
-import sys; print sys.version
-if __name__ == "__main__":
-    demo_plotter(sample_graph())

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changeset 10bfeb3 in sasview for plottools/src/danse/common/plottools/plottables.py

Legend:

plottools/src/danse/common/plottools/plottables.py

Download in other formats: