PyX

Revision: 3235
          http://pyx.svn.sourceforge.net/pyx/?rev=3235&view=rev
Author:   wobsta
Date:     2011-12-09 21:28:10 +0000 (Fri, 09 Dec 2011)
Log Message:
-----------
move plotitems to the graph styles

Modified Paths:
--------------
    trunk/pyx/pyx/graph/graph.py
    trunk/pyx/pyx/graph/style.py

Modified: trunk/pyx/pyx/graph/graph.py
===================================================================
--- trunk/pyx/pyx/graph/graph.py	2011-12-09 20:46:52 UTC (rev 3234)
+++ trunk/pyx/pyx/graph/graph.py	2011-12-09 21:28:10 UTC (rev 3235)
@@ -31,100 +31,6 @@
 goldenmean = 0.5 * (math.sqrt(5) + 1)
 
 
-class styledata:
-    """style data storage class
-
-    Instances of this class are used to store data from the styles
-    and to pass point data to the styles by instances named privatedata
-    and sharedata. sharedata is shared between all the style(s) in use
-    by a data instance, while privatedata is private to each style and
-    used as a storage place instead of self to prevent side effects when
-    using a style several times."""
-    pass
-
-
-class plotitem:
-
-    def __init__(self, graph, data, styles):
-        self.data = data
-        self.title = data.title
-
-        addstyles = [None]
-        while addstyles:
-            # add styles to ensure all needs of the given styles
-            provided = [] # already provided sharedata variables
-            addstyles = [] # a list of style instances to be added in front
-            for s in styles:
-                for n in s.needsdata:
-                    if n not in provided:
-                        defaultprovider = style.getdefaultprovider(n)
-                        addstyles.append(defaultprovider)
-                        provided.extend(defaultprovider.providesdata)
-                provided.extend(s.providesdata)
-            styles = addstyles + styles
-
-        self.styles = styles
-        self.sharedata = styledata()
-        self.privatedatalist = [styledata() for s in self.styles]
-
-        # perform setcolumns to all styles
-        self.usedcolumnnames = []
-        for privatedata, s in zip(self.privatedatalist, self.styles):
-            self.usedcolumnnames.extend(s.columnnames(privatedata, self.sharedata, graph, self.data.columnnames))
-
-    def selectstyles(self, graph, selectindex, selecttotal):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.selectstyle(privatedata, self.sharedata, graph, selectindex, selecttotal)
-
-    def adjustaxesstatic(self, graph):
-        for columnname, data in self.data.columns.items():
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
-
-    def makedynamicdata(self, graph):
-        self.dynamiccolumns = self.data.dynamiccolumns(graph)
-
-    def adjustaxesdynamic(self, graph):
-        for columnname, data in self.dynamiccolumns.items():
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
-
-    def draw(self, graph):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.initdrawpoints(privatedata, self.sharedata, graph)
-        point = {}
-        useitems = []
-        for columnname in self.usedcolumnnames:
-            try:
-                useitems.append((columnname, self.dynamiccolumns[columnname]))
-            except KeyError:
-                useitems.append((columnname, self.data.columns[columnname]))
-        if not useitems:
-            raise ValueError("cannot draw empty data")
-        for i in xrange(len(useitems[0][1])):
-            for columnname, data in useitems:
-                point[columnname] = data[i]
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.drawpoint(privatedata, self.sharedata, graph, point)
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.donedrawpoints(privatedata, self.sharedata, graph)
-
-    def key_pt(self, graph, x_pt, y_pt, width_pt, height_pt):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.key_pt(privatedata, self.sharedata, graph, x_pt, y_pt, width_pt, height_pt)
-
-    def __getattr__(self, attr):
-        # read only access to the styles privatedata
-        stylesdata = [getattr(styledata, attr)
-                      for styledata in self.privatedatalist
-                      if hasattr(styledata, attr)]
-        if len(stylesdata) > 1:
-            return stylesdata
-        elif len(stylesdata) == 1:
-            return stylesdata[0]
-        raise AttributeError("access to styledata attribute '%s' failed" % attr)
-
-
 class graph(canvas.canvas):
 
     def __init__(self):
@@ -187,7 +93,7 @@
                     raise RuntimeError("defaultstyles differ")
         plotitems = []
         for d in usedata:
-            plotitems.append(plotitem(self, d, styles))
+            plotitems.append(style.plotitem(self, d, styles))
         self.plotitems.extend(plotitems)
         if self.didranges:
             for aplotitem in plotitems:

Modified: trunk/pyx/pyx/graph/style.py
===================================================================
--- trunk/pyx/pyx/graph/style.py	2011-12-09 20:46:52 UTC (rev 3234)
+++ trunk/pyx/pyx/graph/style.py	2011-12-09 21:28:10 UTC (rev 3235)
@@ -30,6 +30,102 @@
 builtinrange = range
 
 
+class styledata:
+    """style data storage class
+
+    Instances of this class are used to store data from the styles
+    and to pass point data to the styles by instances named privatedata
+    and sharedata. sharedata is shared between all the style(s) in use
+    by a data instance, while privatedata is private to each style and
+    used as a storage place instead of self to prevent side effects when
+    using a style several times."""
+    pass
+
+
+class plotitem:
+
+    def __init__(self, graph, data, styles):
+        self.data = data
+        self.title = data.title
+
+        addstyles = [None]
+        while addstyles:
+            # add styles to ensure all needs of the given styles
+            provided = [] # already provided sharedata variables
+            addstyles = [] # a list of style instances to be added in front
+            for s in styles:
+                for n in s.needsdata:
+                    if n not in provided:
+                        defaultprovider = style.getdefaultprovider(n)
+                        addstyles.append(defaultprovider)
+                        provided.extend(defaultprovider.providesdata)
+                provided.extend(s.providesdata)
+            styles = addstyles + styles
+
+        self.styles = styles
+        self.sharedata = styledata()
+        self.privatedatalist = [styledata() for s in self.styles]
+
+        # perform setcolumns to all styles
+        self.usedcolumnnames = []
+        for privatedata, s in zip(self.privatedatalist, self.styles):
+            self.usedcolumnnames.extend(s.columnnames(privatedata, self.sharedata, graph, self.data.columnnames))
+
+    def selectstyles(self, graph, selectindex, selecttotal):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.selectstyle(privatedata, self.sharedata, graph, selectindex, selecttotal)
+
+    def adjustaxesstatic(self, graph):
+        for columnname, data in self.data.columns.items():
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+
+    def makedynamicdata(self, graph):
+        self.dynamiccolumns = self.data.dynamiccolumns(graph)
+
+    def adjustaxesdynamic(self, graph):
+        for columnname, data in self.dynamiccolumns.items():
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+
+    def draw(self, graph):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.initdrawpoints(privatedata, self.sharedata, graph)
+        point = {}
+        useitems = []
+        for columnname in self.usedcolumnnames:
+            try:
+                useitems.append((columnname, self.dynamiccolumns[columnname]))
+            except KeyError:
+                useitems.append((columnname, self.data.columns[columnname]))
+        if not useitems:
+            raise ValueError("cannot draw empty data")
+        for i in xrange(len(useitems[0][1])):
+            for columnname, data in useitems:
+                point[columnname] = data[i]
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.drawpoint(privatedata, self.sharedata, graph, point)
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.donedrawpoints(privatedata, self.sharedata, graph)
+
+    def key_pt(self, graph, x_pt, y_pt, width_pt, height_pt):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.key_pt(privatedata, self.sharedata, graph, x_pt, y_pt, width_pt, height_pt)
+
+    def __getattr__(self, attr):
+        # read only access to the styles privatedata
+        # this is just a convenience method
+        # use case: access the path of a the line style
+        stylesdata = [getattr(styledata, attr)
+                      for styledata in self.privatedatalist
+                      if hasattr(styledata, attr)]
+        if len(stylesdata) > 1:
+            return stylesdata
+        elif len(stylesdata) == 1:
+            return stylesdata[0]
+        raise AttributeError("access to styledata attribute '%s' failed" % attr)
+
+
 class _style:
     """Interface class for graph styles
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3286
          http://pyx.svn.sourceforge.net/pyx/?rev=3286&view=rev
Author:   wobsta
Date:     2012-10-11 22:28:19 +0000 (Thu, 11 Oct 2012)
Log Message:
-----------
move plotitem from style to graph

Modified Paths:
--------------
    trunk/pyx/pyx/graph/graph.py
    trunk/pyx/pyx/graph/style.py

Modified: trunk/pyx/pyx/graph/graph.py
===================================================================
--- trunk/pyx/pyx/graph/graph.py	2012-10-09 17:40:55 UTC (rev 3285)
+++ trunk/pyx/pyx/graph/graph.py	2012-10-11 22:28:19 UTC (rev 3286)
@@ -24,13 +24,129 @@
 
 import math, re, string, warnings
 from pyx import canvas, path, trafo, unit
-from pyx.graph import style
 from pyx.graph.axis import axis, positioner
 
 
 goldenmean = 0.5 * (math.sqrt(5) + 1)
 
 
+# The following two methods are used to register and get a default provider
+# for keys. A key is a variable name in sharedata. A provider is a style
+# which creates variables in sharedata.
+
+_defaultprovider = {}
+
+def registerdefaultprovider(style, keys):
+    """sets a style as a default creator for sharedata variables 'keys'"""
+    for key in keys:
+        assert key in style.providesdata, "key not provided by style"
+        # we might allow for overwriting the defaults, i.e. the following is not checked:
+        # assert key in _defaultprovider.keys(), "default provider already registered for key"
+        _defaultprovider[key] = style
+
+def getdefaultprovider(key):
+    """returns a style, which acts as a default creator for the
+    sharedata variable 'key'"""
+    return _defaultprovider[key]
+
+
+class styledata:
+    """style data storage class
+
+    Instances of this class are used to store data from the styles
+    and to pass point data to the styles by instances named privatedata
+    and sharedata. sharedata is shared between all the style(s) in use
+    by a data instance, while privatedata is private to each style and
+    used as a storage place instead of self to prevent side effects when
+    using a style several times."""
+    pass
+
+
+class plotitem:
+
+    def __init__(self, graph, data, styles):
+        self.data = data
+        self.title = data.title
+
+        addstyles = [None]
+        while addstyles:
+            # add styles to ensure all needs of the given styles
+            provided = [] # already provided sharedata variables
+            addstyles = [] # a list of style instances to be added in front
+            for s in styles:
+                for n in s.needsdata:
+                    if n not in provided:
+                        defaultprovider = getdefaultprovider(n)
+                        addstyles.append(defaultprovider)
+                        provided.extend(defaultprovider.providesdata)
+                provided.extend(s.providesdata)
+            styles = addstyles + styles
+
+        self.styles = styles
+        self.sharedata = styledata()
+        self.dataaxisnames = {}
+        self.privatedatalist = [styledata() for s in self.styles]
+
+        # perform setcolumns to all styles
+        self.usedcolumnnames = pycompat.set()
+        for privatedata, s in zip(self.privatedatalist, self.styles):
+            self.usedcolumnnames.update(pycompat.set(s.columnnames(privatedata, self.sharedata, graph, self.data.columnnames, self.dataaxisnames)))
+
+    def selectstyles(self, graph, selectindex, selecttotal):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.selectstyle(privatedata, self.sharedata, graph, selectindex, selecttotal)
+
+    def adjustaxesstatic(self, graph):
+        for columnname, data in self.data.columns.items():
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+
+    def makedynamicdata(self, graph):
+        self.dynamiccolumns = self.data.dynamiccolumns(graph, self.dataaxisnames)
+
+    def adjustaxesdynamic(self, graph):
+        for columnname, data in self.dynamiccolumns.items():
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+
+    def draw(self, graph):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.initdrawpoints(privatedata, self.sharedata, graph)
+        point = {}
+        useitems = []
+        for columnname in self.usedcolumnnames:
+            try:
+                useitems.append((columnname, self.dynamiccolumns[columnname]))
+            except KeyError:
+                useitems.append((columnname, self.data.columns[columnname]))
+        if not useitems:
+            raise ValueError("cannot draw empty data")
+        for i in xrange(len(useitems[0][1])):
+            for columnname, data in useitems:
+                point[columnname] = data[i]
+            for privatedata, style in zip(self.privatedatalist, self.styles):
+                style.drawpoint(privatedata, self.sharedata, graph, point)
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.donedrawpoints(privatedata, self.sharedata, graph)
+
+    def key_pt(self, graph, x_pt, y_pt, width_pt, height_pt):
+        for privatedata, style in zip(self.privatedatalist, self.styles):
+            style.key_pt(privatedata, self.sharedata, graph, x_pt, y_pt, width_pt, height_pt)
+
+    def __getattr__(self, attr):
+        # read only access to the styles privatedata
+        # this is just a convenience method
+        # use case: access the path of a the line style
+        stylesdata = [getattr(styledata, attr)
+                      for styledata in self.privatedatalist
+                      if hasattr(styledata, attr)]
+        if len(stylesdata) > 1:
+            return stylesdata
+        elif len(stylesdata) == 1:
+            return stylesdata[0]
+        raise AttributeError("access to styledata attribute '%s' failed" % attr)
+
+
 class graph(canvas.canvas):
 
     def __init__(self):
@@ -96,7 +212,7 @@
                     raise RuntimeError("defaultstyles differ")
         plotitems = []
         for d in usedata:
-            plotitems.append(style.plotitem(self, d, styles))
+            plotitems.append(plotitem(self, d, styles))
         self.plotitems.extend(plotitems)
         if self.didranges:
             for aplotitem in plotitems:

Modified: trunk/pyx/pyx/graph/style.py
===================================================================
--- trunk/pyx/pyx/graph/style.py	2012-10-09 17:40:55 UTC (rev 3285)
+++ trunk/pyx/pyx/graph/style.py	2012-10-11 22:28:19 UTC (rev 3286)
@@ -25,107 +25,12 @@
 import math, warnings, cStringIO
 from pyx import attr, deco, style, color, unit, canvas, path, mesh, pycompat, trafo
 from pyx import text as textmodule
+from graph import registerdefaultprovider
 from pyx import bitmap as bitmapmodule
 
 builtinrange = range
 
 
-class styledata:
-    """style data storage class
-
-    Instances of this class are used to store data from the styles
-    and to pass point data to the styles by instances named privatedata
-    and sharedata. sharedata is shared between all the style(s) in use
-    by a data instance, while privatedata is private to each style and
-    used as a storage place instead of self to prevent side effects when
-    using a style several times."""
-    pass
-
-
-class plotitem:
-
-    def __init__(self, graph, data, styles):
-        self.data = data
-        self.title = data.title
-
-        addstyles = [None]
-        while addstyles:
-            # add styles to ensure all needs of the given styles
-            provided = [] # already provided sharedata variables
-            addstyles = [] # a list of style instances to be added in front
-            for s in styles:
-                for n in s.needsdata:
-                    if n not in provided:
-                        defaultprovider = getdefaultprovider(n)
-                        addstyles.append(defaultprovider)
-                        provided.extend(defaultprovider.providesdata)
-                provided.extend(s.providesdata)
-            styles = addstyles + styles
-
-        self.styles = styles
-        self.sharedata = styledata()
-        self.privatedatalist = [styledata() for s in self.styles]
-
-        # perform setcolumns to all styles
-        self.usedcolumnnames = []
-        for privatedata, s in zip(self.privatedatalist, self.styles):
-            self.usedcolumnnames.extend(s.columnnames(privatedata, self.sharedata, graph, self.data.columnnames))
-
-    def selectstyles(self, graph, selectindex, selecttotal):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.selectstyle(privatedata, self.sharedata, graph, selectindex, selecttotal)
-
-    def adjustaxesstatic(self, graph):
-        for columnname, data in self.data.columns.items():
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
-
-    def makedynamicdata(self, graph):
-        self.dynamiccolumns = self.data.dynamiccolumns(graph)
-
-    def adjustaxesdynamic(self, graph):
-        for columnname, data in self.dynamiccolumns.items():
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
-
-    def draw(self, graph):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.initdrawpoints(privatedata, self.sharedata, graph)
-        point = {}
-        useitems = []
-        for columnname in self.usedcolumnnames:
-            try:
-                useitems.append((columnname, self.dynamiccolumns[columnname]))
-            except KeyError:
-                useitems.append((columnname, self.data.columns[columnname]))
-        if not useitems:
-            raise ValueError("cannot draw empty data")
-        for i in xrange(len(useitems[0][1])):
-            for columnname, data in useitems:
-                point[columnname] = data[i]
-            for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.drawpoint(privatedata, self.sharedata, graph, point)
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.donedrawpoints(privatedata, self.sharedata, graph)
-
-    def key_pt(self, graph, x_pt, y_pt, width_pt, height_pt):
-        for privatedata, style in zip(self.privatedatalist, self.styles):
-            style.key_pt(privatedata, self.sharedata, graph, x_pt, y_pt, width_pt, height_pt)
-
-    def __getattr__(self, attr):
-        # read only access to the styles privatedata
-        # this is just a convenience method
-        # use case: access the path of a the line style
-        stylesdata = [getattr(styledata, attr)
-                      for styledata in self.privatedatalist
-                      if hasattr(styledata, attr)]
-        if len(stylesdata) > 1:
-            return stylesdata
-        elif len(stylesdata) == 1:
-            return stylesdata[0]
-        raise AttributeError("access to styledata attribute '%s' failed" % attr)
-
-
 class _style:
     """Interface class for graph styles
 
@@ -204,26 +109,6 @@
         """Draw graph key"""
 
 
-# The following two methods are used to register and get a default provider
-# for keys. A key is a variable name in sharedata. A provider is a style
-# which creates variables in sharedata.
-
-_defaultprovider = {}
-
-def registerdefaultprovider(style, keys):
-    """sets a style as a default creator for sharedata variables 'keys'"""
-    for key in keys:
-        assert key in style.providesdata, "key not provided by style"
-        # we might allow for overwriting the defaults, i.e. the following is not checked:
-        # assert key in _defaultprovider.keys(), "default provider already registered for key"
-        _defaultprovider[key] = style
-
-def getdefaultprovider(key):
-    """returns a style, which acts as a default creator for the
-    sharedata variable 'key'"""
-    return _defaultprovider[key]
-
-
 class pos(_style):
 
     providesdata = ["vpos", "vposmissing", "vposavailable", "vposvalid", "poscolumnnames"]

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3287
          http://pyx.svn.sourceforge.net/pyx/?rev=3287&view=rev
Author:   wobsta
Date:     2012-10-11 22:31:00 +0000 (Thu, 11 Oct 2012)
Log Message:
-----------
add a one dimensional graph

Modified Paths:
--------------
    trunk/pyx/pyx/graph/__init__.py
    trunk/pyx/pyx/graph/graph.py

Modified: trunk/pyx/pyx/graph/__init__.py
===================================================================
--- trunk/pyx/pyx/graph/__init__.py	2012-10-11 22:28:19 UTC (rev 3286)
+++ trunk/pyx/pyx/graph/__init__.py	2012-10-11 22:31:00 UTC (rev 3287)
@@ -22,11 +22,11 @@
 
 __allmodules__ = ["data", "key", "style", "axis"]
 for module in __allmodules__:
-    __import__(module, globals(), locals(), [])
+__import__(module, globals(), locals(), [])
 
-import graph
-__allgraph__ = ["graphxy", "graphxyz"]
-for importfromgraph in __allgraph__:
-    locals()[importfromgraph] = getattr(graph, importfromgraph)
+    import graph
+    __allgraph__ = ["graphx", "graphxy", "graphxyz"]
+    for importfromgraph in __allgraph__:
+locals()[importfromgraph] = getattr(graph, importfromgraph)
 
-__all__ = __allmodules__ + __allgraph__
+    __all__ = __allmodules__ + __allgraph__

Modified: trunk/pyx/pyx/graph/graph.py
===================================================================
--- trunk/pyx/pyx/graph/graph.py	2012-10-11 22:28:19 UTC (rev 3286)
+++ trunk/pyx/pyx/graph/graph.py	2012-10-11 22:31:00 UTC (rev 3287)
@@ -23,7 +23,7 @@
 
 
 import math, re, string, warnings
-from pyx import canvas, path, trafo, unit
+from pyx import canvas, path, pycompat, trafo, unit
 from pyx.graph.axis import axis, positioner
 
 
@@ -580,6 +580,61 @@
                 self.layer("key").insert(c, [trafo.translate_pt(x, y)])
 
 
+
+class graphx(graphxy):
+
+    def __init__(self, xpos=0, ypos=0, length=None, size=0.5*unit.v_cm, direction="vertical",
+                 key=None, backgroundattrs=None, axesdist=0.8*unit.v_cm, **axes):
+        for name in axes:
+            if not name.startswith("x"):
+                raise ValueError("Only x axes are allowed")
+        self.direction = direction
+        if self.direction == "vertical":
+            kwargsxy = dict(width=size, height=length, flipped=True)
+        elif self.direction == "horizontal":
+            kwargsxy = dict(width=length, height=size)
+        else:
+            raise ValueError("vertical or horizontal direction required")
+        kwargsxy.update(**axes)
+
+        graphxy.__init__(self, xpos=xpos, ypos=ypos, ratio=None, key=key, y=axis.lin(min=0, max=1, parter=None),
+                         backgroundattrs=backgroundattrs, axesdist=axesdist, **kwargsxy)
+
+    def pos_pt(self, x, xaxis=None):
+        return graphxy.pos_pt(self, x, 0.5, xaxis)
+
+    def pos(self, x, xaxis=None):
+        return graphxy.pos(self, x, 0.5, xaxis)
+
+    def vpos_pt(self, vx):
+        return graphxy.vpos_pt(self, vx, 0.5)
+
+    def vpos(self, vx):
+        return graphxy.vpos(self, vx, 0.5)
+
+    def vgeodesic(self, vx1, vx2):
+        return graphxy.vgeodesic(self, vx1, 0.5, vx2, 0.5)
+
+    def vgeodesic_el(self, vx1, vy1, vx2, vy2):
+        return graphxy.vgeodesic_el(self, vx1, 0.5, vx2, 0.5)
+
+    def vcap_pt(self, coordinate, length_pt, vx):
+        if coordinate == 0:
+            return graphxy.vcap_pt(self, coordinate, length_pt, vx, 0.5)
+        else:
+            raise ValueError("direction invalid")
+
+    def xvgridpath(self, vx):
+        return graphxy.xvgridpath(self, vx)
+
+    def yvgridpath(self, vy):
+        raise Exception("This method does not exist on a one dimensional graph.")
+
+    def axisatv(self, axis, v):
+        raise Exception("This method does not exist on a one dimensional graph.")
+
+
+
 class graphxyz(graphxy):
 
     class central:

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3302
          http://pyx.svn.sourceforge.net/pyx/?rev=3302&view=rev
Author:   wobsta
Date:     2012-10-12 20:55:07 +0000 (Fri, 12 Oct 2012)
Log Message:
-----------
keygraph alignment, initialization, etc.

Modified Paths:
--------------
    trunk/pyx/pyx/graph/graph.py
    trunk/pyx/pyx/graph/style.py

Modified: trunk/pyx/pyx/graph/graph.py
===================================================================
--- trunk/pyx/pyx/graph/graph.py	2012-10-12 20:05:23 UTC (rev 3301)
+++ trunk/pyx/pyx/graph/graph.py	2012-10-12 20:55:07 UTC (rev 3302)
@@ -99,7 +99,7 @@
     def adjustaxesstatic(self, graph):
         for columnname, data in self.data.columns.items():
             for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+                style.adjustaxis(privatedata, self.sharedata, graph, self, columnname, data)
 
     def makedynamicdata(self, graph):
         self.dynamiccolumns = self.data.dynamiccolumns(graph, self.dataaxisnames)
@@ -107,7 +107,7 @@
     def adjustaxesdynamic(self, graph):
         for columnname, data in self.dynamiccolumns.items():
             for privatedata, style in zip(self.privatedatalist, self.styles):
-                style.adjustaxis(privatedata, self.sharedata, graph, columnname, data)
+                style.adjustaxis(privatedata, self.sharedata, graph, self, columnname, data)
 
     def draw(self, graph):
         for privatedata, style in zip(self.privatedatalist, self.styles):
@@ -499,6 +499,33 @@
         return path.line_pt(self.xpos_pt, self.ypos_pt + vy*self.height_pt,
                             self.xpos_pt + self.width_pt, self.ypos_pt + vy*self.height_pt)
 
+    def autokeygraphattrs(self):
+        return dict(direction="vertical", length=self.height)
+
+    def autokeygraphtrafo(self, keygraph):
+        dependsonaxisnumber = None
+        if self.flipped:
+            dependsonaxisname = "x"
+        else:
+            dependsonaxisname = "y"
+        for axisname in self.axes:
+            if axisname[0] == dependsonaxisname:
+                if len(axisname) == 1:
+                    axisname += "1"
+                axisnumber = int(axisname[1:])
+                if not (axisnumber % 2) and not self.flipped or (axisnumber % 2) and self.flipped:
+                    if dependsonaxisnumber is None or dependsonaxisnumber < axisnumber:
+                        dependsonaxisnumber = axisnumber
+        if dependsonaxisnumber is None:
+            x_pt = self.xpos_pt + self.width_pt
+        else:
+            if dependsonaxisnumber > 1:
+                dependsonaxisname += str(dependsonaxisnumber)
+            self.doaxiscreate(dependsonaxisname)
+            x_pt = self.axes[dependsonaxisname].positioner.x1_pt + self.axes[dependsonaxisname].canvas.extent_pt
+        x_pt += self.axesdist_pt
+        return trafo.translate_pt(x_pt, self.ypos_pt)
+
     def axisatv(self, axis, v):
         if axis.positioner.fixtickdirection[0]:
             # it is a y-axis

Modified: trunk/pyx/pyx/graph/style.py
===================================================================
--- trunk/pyx/pyx/graph/style.py	2012-10-12 20:05:23 UTC (rev 3301)
+++ trunk/pyx/pyx/graph/style.py	2012-10-12 20:55:07 UTC (rev 3302)
@@ -74,7 +74,7 @@
         name."""
         return []
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         """Adjust axis range
 
         This method is called in order to adjust the axis range to
@@ -151,7 +151,7 @@
         dataaxisnames.update(privatedata.axisnames)
         return [columnname for columnname in privatedata.poscolumnnames if columnname is not None]
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         if columnname in privatedata.axisnames:
             graph.axes[privatedata.axisnames[columnname]].adjustaxis(data)
 
@@ -263,7 +263,7 @@
                     sharedata.vrangemaxmissing.append(count)
         return usecolumns
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         for axisname, usename, mask in privatedata.rangeposcolumns:
             if columnname == usename + "min" and mask & self.mask_min:
                 graph.axes[axisname].adjustaxis(data)
@@ -664,7 +664,7 @@
         else:
             privatedata.lineattrs = None
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         if self.fromvalue is not None:
             try:
                 i = sharedata.poscolumnnames.index(columnname)
@@ -1004,7 +1004,7 @@
             privatedata.autohistogram = 0
         return []
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         if privatedata.autohistogram and columnname == sharedata.poscolumnnames[privatedata.rangeaxisindex]:
             if len(data) == 1:
                 raise ValueError("several data points needed for automatic histogram width calculation")
@@ -1356,7 +1356,7 @@
         else:
             return value, subvalue
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         try:
             i = sharedata.barposcolumnnames.index(columnname)
         except ValueError:
@@ -1433,7 +1433,7 @@
             raise ValueError("column '%s' missing" % self.stackname)
         return [self.stackname]
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         if columnname == self.stackname:
             graph.axes[sharedata.barposcolumnnames[sharedata.barvalueindex]].adjustaxis(data)
 
@@ -1922,36 +1922,42 @@
         graph.layer("filldata").insert(m)
 
 
-class _autokeygraph:
+class _autokeygraph: pass
+class _copyfromdata: pass
+class _grabfromdata: pass
 
-    pass
+class density(_style):
 
+    autographkey = _autokeygraph
+    copyfromdata = _copyfromdata
+    grabfromdata = _grabfromdata
 
-class density(_style):
-
     needsdata = ["values1", "values2", "data12", "data21"]
 
-    def __init__(self, colorname="color", gradient=color.gradient.Grey, coloraxis=axis.lin(), epsilon=1e-10, key=_autokeygraph):
+    def __init__(self, colorname="color", gradient=color.gradient.Grey, coloraxis=axis.lin(title=_grabfromdata), epsilon=1e-10, keygraph=_autokeygraph):
         self.colorname = colorname
         self.gradient = gradient
         self.coloraxis = coloraxis
         self.epsilon = epsilon
-        self.key = key
+        self.keygraph = keygraph
 
     def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
         return [self.colorname]
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         if columnname == self.colorname:
-            if self.key is None:
+            if self.keygraph is None:
                 # we always need a keygraph, but we might not show it
-                privatedata.keygraph = graphx(0, 0, length=10, direction="vertical", x=self.coloraxis)
-            elif self.key is _autokeygraph:
-                # TODO: take axes into account
+                privatedata.keygraph = graphx(length=10, direction="vertical", x=self.coloraxis)
+            elif self.keygraph is _autokeygraph:
                 # TODO: auto positioning for 3d graphs
-                privatedata.keygraph = graphx(graph.xpos + graph.width + 1, graph.ypos, length=graph.height, direction="vertical", x=self.coloraxis)
+                if self.coloraxis.title is _grabfromdata:
+                    plotitem.title, self.coloraxis.title = None, plotitem.title
+                elif self.coloraxis.title is _copyfromdata:
+                    self.coloraxis.title = plotitem.title
+                privatedata.keygraph = graphx(x=self.coloraxis, **graph.autokeygraphattrs())
             else:
-                privatedata.keygraph = keygraph
+                privatedata.keygraph = self.keygraph
             # TODO: we shouldn't have multiple plotitems
             privatedata.keygraph.plot(datamodule.values(x=data), [gradient(gradient=self.gradient)])
 
@@ -2079,8 +2085,8 @@
         c.insert(b)
         graph.layer("filldata").insert(c)
 
-        if self.key is not None:
-            graph.layer("key").insert(privatedata.keygraph)
+        if self.keygraph is _autokeygraph:
+            graph.layer("key").insert(privatedata.keygraph, [graph.autokeygraphtrafo(privatedata.keygraph)])
 
 
 
@@ -2096,7 +2102,7 @@
     def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
         return [self.columnname]
 
-    def adjustaxis(self, privatedata, sharedata, graph, columnname, data):
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
         graph.axes[self.columnname].adjustaxis(data)
 
     def selectstyle(self, privatedata, sharedata, graph, selectindex, selecttotal):

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 3303
          http://pyx.svn.sourceforge.net/pyx/?rev=3303&view=rev
Author:   wobsta
Date:     2012-10-12 22:10:54 +0000 (Fri, 12 Oct 2012)
Log Message:
-----------
keygraph alignment on 3d graphs; use keygraph in surface and rect style

Modified Paths:
--------------
    trunk/pyx/pyx/graph/graph.py
    trunk/pyx/pyx/graph/style.py

Modified: trunk/pyx/pyx/graph/graph.py
===================================================================
--- trunk/pyx/pyx/graph/graph.py	2012-10-12 20:55:07 UTC (rev 3302)
+++ trunk/pyx/pyx/graph/graph.py	2012-10-12 22:10:54 UTC (rev 3303)
@@ -670,7 +670,7 @@
 
 
 
-class graphxyz(graphxy):
+class graphxyz(graph):
 
     class central:
 
@@ -750,7 +750,7 @@
 
     def __init__(self, xpos=0, ypos=0, size=None,
                  xscale=1, yscale=1, zscale=1/goldenmean,
-                 projector=central(10, -30, 30), key=None,
+                 projector=central(10, -30, 30), axesdist=0.8*unit.v_cm, key=None,
                  **axes):
         graph.__init__(self)
 
@@ -764,6 +764,7 @@
         self.yscale = yscale
         self.zscale = zscale
         self.projector = projector
+        self.axesdist_pt = unit.topt(axesdist)
         self.key = key
 
         self.xorder = projector.zindex(0, -1, 0) > projector.zindex(0, 1, 0) and 1 or 0
@@ -953,6 +954,15 @@
                          path.lineto_pt(*self.vpos_pt(0, 1, vz)),
                          path.closepath())
 
+    def autokeygraphattrs(self):
+        return dict(direction="vertical", length=self.size)
+
+    def autokeygraphtrafo(self, keygraph):
+        self.doaxes()
+        x_pt = self.layer("axes").bbox().right_pt() + self.axesdist_pt
+        y_pt = 0.5*(self.layer("axes").bbox().top_pt() + self.layer("axes").bbox().bottom_pt() - self.size_pt)
+        return trafo.translate_pt(x_pt, y_pt)
+
     def doaxispositioner(self, axisname):
         if self.did(self.doaxispositioner, axisname):
             return

Modified: trunk/pyx/pyx/graph/style.py
===================================================================
--- trunk/pyx/pyx/graph/style.py	2012-10-12 20:55:07 UTC (rev 3302)
+++ trunk/pyx/pyx/graph/style.py	2012-10-12 22:10:54 UTC (rev 3303)
@@ -112,8 +112,60 @@
 
     def key_pt(self, privatedata, sharedata, graph, x_pt, y_pt, width_pt, height_pt):
         """Draw graph key"""
+        pass
 
 
+class _autokeygraph: pass
+class _copyfromdata: pass
+class _grabfromdata: pass
+
+
+class _keygraphstyle(_style):
+
+    autographkey = _autokeygraph
+    copyfromdata = _copyfromdata
+    grabfromdata = _grabfromdata
+
+    def __init__(self, colorname="color", gradient=color.gradient.Grey, coloraxis=axis.lin(title=_grabfromdata), keygraph=_autokeygraph):
+        self.colorname = colorname
+        self.gradient = gradient
+        self.coloraxis = coloraxis
+        self.keygraph = keygraph
+
+    def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
+        return [self.colorname]
+
+    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
+        if columnname == self.colorname:
+            if self.keygraph is None:
+                # we always need a keygraph, but we might not show it
+                privatedata.keygraph = graphx(length=10, direction="vertical", x=self.coloraxis)
+            elif self.keygraph is _autokeygraph:
+                if self.coloraxis.title is _grabfromdata:
+                    plotitem.title, self.coloraxis.title = None, plotitem.title
+                elif self.coloraxis.title is _copyfromdata:
+                    self.coloraxis.title = plotitem.title
+                privatedata.keygraph = graphx(x=self.coloraxis, **graph.autokeygraphattrs())
+            else:
+                privatedata.keygraph = self.keygraph
+            # TODO: we shouldn't have multiple plotitems
+            privatedata.keygraph.plot(datamodule.values(x=data), [gradient(gradient=self.gradient)])
+
+    def color(self, privatedata, c):
+        vc = privatedata.keygraph.axes["x"].convert(c)
+        if vc < 0:
+            warnings.warn("gradiend color range is exceeded (lower bound)")
+            vc = 0
+        if vc > 1:
+            warnings.warn("gradiend color range is exceeded (upper bound)")
+            vc = 1
+        return self.gradient.getcolor(vc)
+
+    def donedrawpoints(self, privatedata, sharedata, graph):
+        if self.keygraph is _autokeygraph:
+            graph.layer("key").insert(privatedata.keygraph, [graph.autokeygraphtrafo(privatedata.keygraph)])
+
+
 class pos(_style):
 
     providesdata = ["vpos", "vposmissing", "vposavailable", "vposvalid", "poscolumnnames"]
@@ -919,21 +971,16 @@
         raise RuntimeError("Style currently doesn't provide a graph key")
 
 
-class rect(_style):
+class rect(_keygraphstyle):
 
     needsdata = ["vrange", "vrangeminmissing", "vrangemaxmissing"]
 
-    def __init__(self, gradient=color.gradient.Grey):
-        self.gradient = gradient
-
     def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
         if len(graph.axesnames) != 2:
-            raise TypeError("arrow style restricted on two-dimensional graphs")
-        if "color" not in columnnames:
-            raise ValueError("color missing")
+            raise TypeError("rect style restricted on two-dimensional graphs")
         if len(sharedata.vrangeminmissing) + len(sharedata.vrangemaxmissing):
             raise ValueError("incomplete range")
-        return ["color"]
+        return _keygraphstyle.columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames)
 
     def initdrawpoints(self, privatedata, sharedata, graph):
         privatedata.rectcanvas = graph.layer("filldata").insert(canvas.canvas())
@@ -960,12 +1007,9 @@
             p.append(graph.vgeodesic_el(xvmax, yvmax, xvmin, yvmax))
             p.append(graph.vgeodesic_el(xvmin, yvmax, xvmin, yvmin))
             p.append(path.closepath())
-            privatedata.rectcanvas.fill(p, [self.gradient.getcolor(point["color"])])
+            privatedata.rectcanvas.fill(p, [self.color(privatedata, point["color"])])
 
-    def key_pt(self, privatedata, sharedata, graph, x_pt, y_pt, width_pt, height_pt):
-        raise RuntimeError("Style currently doesn't provide a graph key")
 
-
 class histogram(_style):
 
     needsdata = ["vpos", "vposmissing", "vrange", "vrangeminmissing", "vrangemaxmissing"]
@@ -1700,23 +1744,19 @@
                     graph.layer("data").stroke(p, privatedata.gridattrs)
 
 
-class surface(_style):
+class surface(_keygraphstyle):
 
     needsdata = ["values1", "values2", "data12", "data21"]
 
-    def __init__(self, colorname="color", gradient=color.gradient.Grey, mincolor=None, maxcolor=None,
-                       gridlines1=0.05, gridlines2=0.05, gridcolor=None,
-                       backcolor=color.gray.black):
-        self.colorname = colorname
-        self.gradient = gradient
-        self.mincolor = mincolor
-        self.maxcolor = maxcolor
+    def __init__(self, gridlines1=0.05, gridlines2=0.05, gridcolor=None,
+                       backcolor=color.gray.black, **kwargs):
+        _keygraphstyle.__init__(self, **kwargs)
         self.gridlines1 = gridlines1
         self.gridlines2 = gridlines2
         self.gridcolor = gridcolor
         self.backcolor = backcolor
 
-        colorspacestring = gradient.getcolor(0).colorspacestring()
+        colorspacestring = self.gradient.getcolor(0).colorspacestring()
         if self.gridcolor is not None and self.gridcolor.colorspacestring() != colorspacestring:
             raise RuntimeError("colorspace mismatch (gradient/grid)")
         if self.backcolor is not None and self.backcolor.colorspacestring() != colorspacestring:
@@ -1736,7 +1776,7 @@
     def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
         privatedata.colorize = self.colorname in columnnames
         if privatedata.colorize:
-            return [self.colorname]
+            return _keygraphstyle.columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames)
         return []
 
     def initdrawpoints(self, privatedata, sharedata, graph):
@@ -1798,11 +1838,6 @@
         sortElements = [(zindex, i) for i, zindex in enumerate(sortElements)]
         sortElements.sort()
 
-        mincolor, maxcolor = privatedata.mincolor, privatedata.maxcolor
-        if self.mincolor is not None:
-            mincolor = self.mincolor
-        if self.maxcolor is not None:
-            maxcolor = self.maxcolor
         nodes = []
         elements = []
         for value1a, value1b in zip(values1[:-1], values1[1:]):
@@ -1840,25 +1875,16 @@
                 x4_pt, y4_pt = graph.vpos_pt(*v4)
                 x5_pt, y5_pt = graph.vpos_pt(*v5)
                 if privatedata.colorize:
-                    def colorfromgradient(c):
-                        vc = (c - mincolor) / float(maxcolor - mincolor)
-                        if vc < 0:
-                            warnings.warn("gradiend color range is exceeded due to mincolor setting")
-                            vc = 0
-                        if vc > 1:
-                            warnings.warn("gradiend color range is exceeded due to maxcolor setting")
-                            vc = 1
-                        return self.gradient.getcolor(vc)
                     c1 = privatedata.colors[value1a][value2a]
                     c2 = privatedata.colors[value1a][value2b]
                     c3 = privatedata.colors[value1b][value2a]
                     c4 = privatedata.colors[value1b][value2b]
                     c5 = self.midcolor(c1, c2, c3, c4)
-                    c1a = c1b = colorfromgradient(c1)
-                    c2a = c2c = colorfromgradient(c2)
-                    c3b = c3d = colorfromgradient(c3)
-                    c4c = c4d = colorfromgradient(c4)
-                    c5a = c5b = c5c = c5d = colorfromgradient(c5)
+                    c1a = c1b = self.color(privatedata, c1)
+                    c2a = c2c = self.color(privatedata, c2)
+                    c3b = c3d = self.color(privatedata, c3)
+                    c4c = c4d = self.color(privatedata, c4)
+                    c5a = c5b = c5c = c5d = self.color(privatedata, c5)
                     if self.backcolor is not None and sign*graph.vangle(*(v1+v2+v5)) < 0:
                         c1a = c2a = c5a = self.backcolor
                     if self.backcolor is not None and sign*graph.vangle(*(v3+v1+v5)) < 0:
@@ -1921,46 +1947,18 @@
         m = mesh.mesh(elements, check=0)
         graph.layer("filldata").insert(m)
 
+        if privatedata.colorize:
+            _keygraphstyle.donedrawpoints(self, privatedata, sharedata, graph)
 
-class _autokeygraph: pass
-class _copyfromdata: pass
-class _grabfromdata: pass
 
-class density(_style):
+class density(_keygraphstyle):
 
-    autographkey = _autokeygraph
-    copyfromdata = _copyfromdata
-    grabfromdata = _grabfromdata
-
     needsdata = ["values1", "values2", "data12", "data21"]
 
-    def __init__(self, colorname="color", gradient=color.gradient.Grey, coloraxis=axis.lin(title=_grabfromdata), epsilon=1e-10, keygraph=_autokeygraph):
-        self.colorname = colorname
-        self.gradient = gradient
-        self.coloraxis = coloraxis
+    def __init__(self, epsilon=1e-10, **kwargs):
+        _keygraphstyle.__init__(self, **kwargs)
         self.epsilon = epsilon
-        self.keygraph = keygraph
 
-    def columnnames(self, privatedata, sharedata, graph, columnnames, dataaxisnames):
-        return [self.colorname]
-
-    def adjustaxis(self, privatedata, sharedata, graph, plotitem, columnname, data):
-        if columnname == self.colorname:
-            if self.keygraph is None:
-                # we always need a keygraph, but we might not show it
-                privatedata.keygraph = graphx(length=10, direction="vertical", x=self.coloraxis)
-            elif self.keygraph is _autokeygraph:
-                # TODO: auto positioning for 3d graphs
-                if self.coloraxis.title is _grabfromdata:
-                    plotitem.title, self.coloraxis.title = None, plotitem.title
-                elif self.coloraxis.title is _copyfromdata:
-                    self.coloraxis.title = plotitem.title
-                privatedata.keygraph = graphx(x=self.coloraxis, **graph.autokeygraphattrs())
-            else:
-                privatedata.keygraph = self.keygraph
-            # TODO: we shouldn't have multiple plotitems
-            privatedata.keygraph.plot(datamodule.values(x=data), [gradient(gradient=self.gradient)])
-
     def initdrawpoints(self, privatedata, sharedata, graph):
         privatedata.colors = {}
         privatedata.vfixed = [None]*len(graph.axesnames)
@@ -2027,7 +2025,7 @@
                     data.write(empty)
                     continue
                 c = privatedata.colors[value1][value2]
-                c = self.gradient.getcolor(privatedata.keygraph.axes["x"].convert(c))
+                c = self.color(privatedata, c)
                 if needalpha:
                     data.write(chr(255))
                 data.write(c.to8bitstring())
@@ -2085,8 +2083,7 @@
         c.insert(b)
         graph.layer("filldata").insert(c)
 
-        if self.keygraph is _autokeygraph:
-            graph.layer("key").insert(privatedata.keygraph, [graph.autokeygraphtrafo(privatedata.keygraph)])
+        _keygraphstyle.donedrawpoints(self, privatedata, sharedata, graph)
 
 
 
@@ -2139,6 +2136,3 @@
         b = bitmap.bitmap_trafo(t, i)
         c.insert(b)
         graph.layer("filldata").insert(c)
-
-    def key_pt(self, privatedata, sharedata, graph, x_pt, y_pt, width_pt, height_pt):
-        pass

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.