Menu
▾
▴
SF.net SVN: matplotlib: [5629] trunk/matplotlib
|
From: <jd...@us...> - 2008-06-22 13:53:02
|
Revision: 5629
http://matplotlib.svn.sourceforge.net/matplotlib/?rev=5629&view=rev
Author: jdh2358
Date: 2008-06-22 06:52:43 -0700 (Sun, 22 Jun 2008)
Log Message:
-----------
removed axes3d
Modified Paths:
--------------
trunk/matplotlib/API_CHANGES
trunk/matplotlib/CHANGELOG
trunk/matplotlib/examples/pylab_examples/hline_demo.py
trunk/matplotlib/examples/pylab_examples/image_demo.py
trunk/matplotlib/examples/tests/backend_driver.py
trunk/matplotlib/lib/matplotlib/axes3d.py
Removed Paths:
-------------
trunk/matplotlib/examples/pylab_examples/simple3d.py
trunk/matplotlib/examples/user_interfaces/simple3d_oo.py
trunk/matplotlib/lib/matplotlib/art3d.py
trunk/matplotlib/lib/matplotlib/axis3d.py
trunk/matplotlib/lib/matplotlib/proj3d.py
Modified: trunk/matplotlib/API_CHANGES
===================================================================
--- trunk/matplotlib/API_CHANGES 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/API_CHANGES 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,4 +1,12 @@
+Changes for 0.98.1
+==================
+* Removed broken axes3d support and replaced it with a non implemented
+ error pointing to 0.91.x
+
+Changes for 0.98.0
+==================
+
matplotlib.image.imread now no longer always returns RGBA -- if
the image is luminance or RGB, it will return a MxN or MxNx3 array
if possible. Also uint8 is no longer always forced to float.
Modified: trunk/matplotlib/CHANGELOG
===================================================================
--- trunk/matplotlib/CHANGELOG 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/CHANGELOG 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,3 +1,6 @@
+2008-06-22 Removed axes3d support and replaced it with a
+ NotImplementedError for one release cycle
+
2008-06-21 fix marker placement bug in backend_ps - DSD
2008-06-20 [ 1978629 ] scale documentation missing/incorrect for log - MGD
Modified: trunk/matplotlib/examples/pylab_examples/hline_demo.py
===================================================================
--- trunk/matplotlib/examples/pylab_examples/hline_demo.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/examples/pylab_examples/hline_demo.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -17,5 +17,6 @@
hlines(t, [0], s)
xlabel('time (s)')
title('Comparison of model with data')
+savefig('test')
show()
Modified: trunk/matplotlib/examples/pylab_examples/image_demo.py
===================================================================
--- trunk/matplotlib/examples/pylab_examples/image_demo.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/examples/pylab_examples/image_demo.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -11,6 +11,6 @@
im = imshow(Z, interpolation='bilinear', cmap=cm.gray,
origin='lower', extent=[-3,3,-3,3])
-#savefig('image_demo')
+savefig('image_demo')
show()
Deleted: trunk/matplotlib/examples/pylab_examples/simple3d.py
===================================================================
--- trunk/matplotlib/examples/pylab_examples/simple3d.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/examples/pylab_examples/simple3d.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-
-from numpy import arange, cos, linspace, ones, pi, sin, outer
-
-import pylab
-import matplotlib.axes3d as axes3d
-
-
-fig = pylab.gcf()
-
-ax3d = axes3d.Axes3D(fig)
-plt = fig.axes.append(ax3d)
-
-delta = pi / 199.0
-u = arange(0, 2*pi+(delta*2), delta*2)
-v = arange(0, pi+delta, delta)
-
-x = outer(cos(u),sin(v))
-y = outer(sin(u),sin(v))
-z = outer(ones(u.shape), cos(v))
-
-#ax3d.plot_wireframe(x,y,z)
-surf = ax3d.plot_surface(x, y, z)
-surf.set_array(linspace(0, 1.0, len(v)))
-
-ax3d.set_xlabel('X')
-ax3d.set_ylabel('Y')
-ax3d.set_zlabel('Z')
-
-pylab.show()
-#pylab.savefig('simple3d.svg')
Modified: trunk/matplotlib/examples/tests/backend_driver.py
===================================================================
--- trunk/matplotlib/examples/tests/backend_driver.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/examples/tests/backend_driver.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -132,9 +132,11 @@
import subprocess
def run(arglist):
try:
- subprocess.call(arglist)
+ ret = subprocess.call(arglist)
except KeyboardInterrupt:
sys.exit()
+ else:
+ return ret
except ImportError:
def run(arglist):
os.system(' '.join(arglist))
@@ -198,12 +200,13 @@
tmpfile.close()
start_time = time.time()
program = [x % {'name': basename} for x in python]
- run(program + [tmpfile_name, switchstring])
+ ret = run(program + [tmpfile_name, switchstring])
end_time = time.time()
- print (end_time - start_time)
+ print (end_time - start_time), ret
#os.system('%s %s %s' % (python, tmpfile_name, switchstring))
os.remove(tmpfile_name)
+
if __name__ == '__main__':
times = {}
default_backends = ['agg', 'ps', 'svg', 'pdf', 'template']
Deleted: trunk/matplotlib/examples/user_interfaces/simple3d_oo.py
===================================================================
--- trunk/matplotlib/examples/user_interfaces/simple3d_oo.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/examples/user_interfaces/simple3d_oo.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,64 +0,0 @@
-#!/usr/bin/env python
-
-import matplotlib
-matplotlib.use('WXAgg')
-
-from wx import *
-import matplotlib.axes3d
-import matplotlib.mlab
-import numpy as npy
-from matplotlib.figure import Figure
-from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg, FigureManager, NavigationToolbar2WxAgg
-
-class PlotFigure(Frame):
- def __init__(self):
- Frame.__init__(self, None, -1, "Test embedded wxFigure")
-
- self.fig = Figure((9,8), 75)
- self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
- self.toolbar = NavigationToolbar2WxAgg(self.canvas)
- self.toolbar.Realize()
-
- self.figmgr = FigureManager(self.canvas, 1, self)
- tw, th = self.toolbar.GetSizeTuple()
- fw, fh = self.canvas.GetSizeTuple()
- self.toolbar.SetSize(Size(fw, th))
- sizer = BoxSizer(VERTICAL)
-
- # This way of adding to sizer allows resizing
- sizer.Add(self.canvas, 1, LEFT|TOP|GROW)
- sizer.Add(self.toolbar, 0, GROW)
- self.SetSizer(sizer)
- self.Fit()
-
- self.plot3d()
-
- def plot3d(self):
- # sample taken from http://www.scipy.org/Cookbook/Matplotlib/mplot3D
- ax3d = matplotlib.axes3d.Axes3D(self.fig)
- plt = self.fig.axes.append(ax3d)
-
- delta = npy.pi / 199.0
- u = npy.arange(0, 2*npy.pi+(delta*2), delta*2)
- v = npy.arange(0, npy.pi+delta, delta)
-
- x = npy.cos(u)[:,npy.newaxis] * npy.sin(v)[npy.newaxis,:]
- y = npy.sin(u)[:,npy.newaxis] * npy.sin(v)[npy.newaxis,:]
- z = npy.ones_like(u)[:,npy.newaxis] * npy.cos(v)[npy.newaxis,:]
- # (there is probably a better way to calculate z)
- print x.shape, y.shape, z.shape
-
- #ax3d.plot_wireframe(x,y,z)
- surf = ax3d.plot_surface(x, y, z)
- surf.set_array(matplotlib.mlab.linspace(0, 1.0, len(v)))
-
- ax3d.set_xlabel('X')
- ax3d.set_ylabel('Y')
- ax3d.set_zlabel('Z')
- #self.fig.savefig('globe')
-
-if __name__ == '__main__':
- app = PySimpleApp(0)
- frame = PlotFigure()
- frame.Show()
- app.MainLoop()
Deleted: trunk/matplotlib/lib/matplotlib/art3d.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/art3d.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/lib/matplotlib/art3d.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,464 +0,0 @@
-#!/usr/bin/python
-# art3d.py
-#
-"""
-Wrap 2D artists so that they can pretend to be 3D
-"""
-
-import lines
-from collections import LineCollection, PolyCollection
-import text
-
-from colors import Normalize
-
-import numpy as np
-import proj3d
-
-class Wrap2D:
- """Wrapper which wraps a 2D object and makes it 3D
-
- Artists are normally rendered by calling the draw method, this class
- causes call_draw3d to be called instead.
- This in turn calls
- draw3d which should play with the 2D coordinates and eventually
- call the original self.draw method through self.orig_draw.
-
- overrides the draw method with draw3d
- remembers the original draw method of the wrapped 2d instance
- """
- def __init__(self, inst2d):
- self.__dict__['_wrapped'] = inst2d
- self.__dict__['remembered'] = {}
- #
- inst2d.orig_draw = inst2d.draw
- self.draw2d = inst2d.draw
- inst2d.draw = self.call_draw3d
-
- def remember(self, *attrs):
- """
- Remember some attributes in the wrapped class
- """
- for attr in attrs:
- assert(hasattr(self._wrapped, attr))
- self.remembered[attr] = 1
-
- def __getattr__(self, k):
- return getattr(self.__dict__['_wrapped'], k)
-
- def __setattr__(self, k, v):
- setattr(self.__dict__['_wrapped'], k, v)
-
- def call_draw3d(self, renderer):
- for k in self.remembered.keys():
- self.remembered[k] = getattr(self, k)
- #
- self.draw3d(renderer)
- #
- for k in self.remembered.keys():
- setattr(self, k, self.remembered[k])
-
- def draw3d(self, renderer):
- raise ValueError, "draw3d should be overridden"
-
-class Text3DW(Wrap2D):
- """Wrap a 2D text object and make it look vaguely 3D"""
- def __init__(self, inst, z=0, dir='z'):
- Wrap2D.__init__(self, inst)
- self._z = z
- self.dir = dir
-
- def draw3d(self, renderer):
- x,y = self.get_position()
- xs,ys,zs = juggle_axes(x,y,self._z,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- self.set_x(xs)
- self.set_y(ys)
- #text.Text.draw(self._wrapped, renderer)
- self.draw2d(renderer)
- self.set_x(x)
- self.set_y(y)
-
-class Text3D(Text3DW):
- def __init__(self, x=0,y=0,z=0,text='', dir='z'):
- inst = text.Text(x,y,text,*args, **kwargs)
- Text3DW.__init__(self, z,dir, inst)
-
-class oText3D(text.Text):
- def __init__(self, x=0,y=0,z=0,text='', dir='z', *args, **kwargs):
- text.Text.__init__(self, x,y,text,*args,**kwargs)
- self.dir = dir
- self._z = _z
-
- def draw(self, renderer):
- x,y = self.get_position()
- xs,ys,zs = juggle_axes(x,y,self._z,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- self.set_x(xs)
- self.set_y(ys)
- text.Text.draw(self, renderer)
- self.set_x(x)
- self.set_y(y)
-
-class Line3D(lines.Line2D):
- """Make a 2D line pretend to be 3D"""
- def __init__(self, xs,ys,zs, *args, **kwargs):
- lines.Line2D.__init__(self, xs,ys, *args, **kwargs)
- self.xs,self.ys,self.zs = xs,ys,zs
-
- def draw(self, renderer):
- xs,ys,zs = proj3d.proj_transform(self.xs,self.ys,self.zs, renderer.M)
- self._x,self._y = xs,ys
-
- lines.Line2D.draw(self, renderer)
-
-class Line3DCollectionW(Wrap2D):
- def __init__(self, inst, segments):
- Wrap2D.__init__(self, inst)
- self.segments_3d = segments
-
- def draw3d(self, renderer):
- xyslist = [
- proj3d.proj_trans_points(points, renderer.M) for points in
- self.segments_3d]
- segments_2d = [zip(xs,ys) for (xs,ys,zs) in xyslist]
- self._segments = segments_2d
- self.draw2d(renderer)
-
-class Line3DCollection(Line3DCollectionW):
- def __init__(self, segments, *args, **kwargs):
- inst = LineCollection(segments, *args, **kwargs)
- Line3DCollectionW.__init__(self, inst, segments)
-
-class Line2DCollectionW(Wrap2D):
- def __init__(self, inst, z=0, dir='z'):
- Wrap2D.__init__(self, inst)
- self.z = z
- self.dir = dir
- self.remember('_segments')
-
- def draw3d(self, renderer):
- #
- segments_3d = [[juggle_axes(x,y,self.z,self.dir) for (x,y) in points]
- for points in self._segments]
- xyslist = [
- proj3d.proj_trans_points(points, renderer.M) for points in
- segments_3d]
- segments_2d = [zip(xs,ys) for (xs,ys,zs) in xyslist]
- #orig_segments = self._segments
- self._segments = segments_2d
- self.draw2d(renderer)
- #self._segments = orig_segments
-
-class Line3DCollection(Line3DCollectionW):
- def __init__(self, segments, *args, **kwargs):
- inst = LineCollection(segments, *args, **kwargs)
- Line3DCollectionW.__init__(self, inst, segments)
-
-class Patch3D(Wrap2D):
- def __init__(self, inst, zs, dir='z'):
- Wrap2D.__init__(self, inst)
- self.zs = zs
- self.dir = dir
- self.remember('get_verts')
-
- def draw3d(self, renderer):
- xs,ys = zip(*self.get_verts())
- xs,ys,zs = juggle_axes(xs,ys,self.zs,self.dir)
- vxs,vys,vzs,vis = proj3d.proj_transform_clip(xs,ys,zs, renderer.M)
- def get_verts(*args):
- verts = zip(vxs,vys)
- return verts
-
- self.get_verts = get_verts
- self.draw2d(renderer)
-
-class Patch3DCollectionW(Wrap2D):
- def __init__(self, inst, zs, dir='z'):
- Wrap2D.__init__(self, inst)
- self.zs = zs
- self.dir = dir
- self.remember('_offsets','_facecolors','_edgecolors')
-
- def draw3d(self, renderer):
- xs,ys = zip(*self._offsets)
- xs,ys,zs = juggle_axes(xs,ys,self.zs,self.dir)
- if 0:
- vxs,vys,vzs,vis = proj3d.proj_transform_clip(xs,ys,zs, renderer.M)
- # mess with colors
- #
- vxs = [x for x,i in zip(vxs,vis) if i]
- vys = [y for y,i in zip(vys,vis) if i]
- else:
- vxs,vys,vzs,vis = proj3d.proj_transform_clip(xs,ys,zs, renderer.M)
- self._facecolors = zalpha(self._facecolors,vzs)
- self._edgecolors = zalpha(self._edgecolors,vzs)
- self._offsets = zip(vxs,vys)
- self.draw2d(renderer)
-
-class Poly3DCollectionW(Wrap2D):
- def __init__(self, inst, zs=None, dir='z'):
- Wrap2D.__init__(self, inst)
- if not zs:
- zs = [0 for v in inst._verts]
- self.zs = [[z for v in verts] for z,verts in zip(zs,inst._verts)]
- self.dir = dir
- self.remember('_verts','_facecolors','_edgecolors')
-
- def draw3d(self, renderer):
- vverts = []
- for zs,verts in zip(self.zs,self._verts):
- xs,ys = zip(*verts)
- xs,ys,zs = juggle_axes(xs,ys,zs,self.dir)
- vxs,vys,vzs,vis = proj3d.proj_transform_clip(xs,ys,zs, renderer.M)
- vverts.append((max(vzs),zip(vxs,vys)))
- vverts.sort()
- vverts.reverse()
- # mess with colors
- self._verts = [verts for (z,verts) in vverts]
- self.draw2d(renderer)
-
-class oLine3DCollection(LineCollection):
- def __init__(self, segments, *args, **kwargs):
- LineCollection.__init__(self, segments, *args, **kwargs)
- self.segments_3d = segments
-
- def draw(self, renderer):
- orig_segments = self._segments
- xyslist = [
- proj3d.proj_trans_points(points, renderer.M) for points in
- self.segments_3d]
- segments_2d = [zip(xs,ys) for (xs,ys,zs) in xyslist]
- self._segments = segments_2d
- LineCollection.draw(self, renderer)
- self._segments = orig_segments
-
-class Poly3DCollection(Wrap2D):
- def __init__(self, segments, *args, **kwargs):
- inst = PolyCollection(segments, *args, **kwargs)
- Wrap2D.__init__(self, inst)
- self._zsort = 1
- self.get_vector()
- self.remember('_facecolors')
- self.remember('_verts')
-
- def get_vector(self):
- """optimise points for projection"""
- si = 0
- ei = 0
- segis = []
- points = []
- for p in self._verts:
- points.extend(p)
- ei = si+len(p)
- segis.append((si,ei))
- si = ei
- xs,ys,zs = zip(*points)
- ones = np.ones(len(xs))
- self.vec = np.array([xs,ys,zs,ones])
- self.segis = segis
-
- def draw3d(self, renderer):
- #
- txs,tys,tzs,tis = proj3d.proj_transform_vec_clip(self.vec,renderer.M)
- xyslist = [(txs[si:ei],tys[si:ei],tzs[si:ei],tis[si:ei]) for si,ei in self.segis]
- colors = get_colors(self._facecolors, len(self._verts))
- #
- # if required sort by depth (furthest drawn first)
- if self._zsort:
- z_segments_2d = [(min(zs),max(tis),zip(xs,ys),c) for
- (xs,ys,zs,tis),c in zip(xyslist,colors)]
- z_segments_2d.sort()
- z_segments_2d.reverse()
- else:
- raise ValueError, "whoops"
- segments_2d = [s for z,i,s,c in z_segments_2d if i]
- colors = [c for z,i,s,c in z_segments_2d if i]
- self._verts = segments_2d
- self._facecolors = colors
-
- self.draw2d(renderer)
-
-def juggle_axes(xs,ys,zs, dir):
- """Depending on the direction of the plot re-order the axis
-
- This is so that 2d plots can be plotted along any direction.
- """
- if dir == 'x': return zs,xs,ys
- elif dir == 'y': return xs,zs,ys
- else: return xs,ys,zs
-
-class Line2DW(Wrap2D):
- def __init__(self, inst, z=0, dir='z'):
- Wrap2D.__init__(self, inst)
- self.z = z
- self.dir = dir
- self.remember('_x','_y')
-
- def draw3d(self, renderer):
- zs = [self.z for x in self._x]
- xs,ys,zs = juggle_axes(self._x,self._y,zs,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- self._x = xs
- self._y = ys
- self.draw2d(renderer)
-
-def line_draw(self, renderer):
- """Draw a 2D line as a 3D line"""
- oxs,oys = self.get_xdata(),self.get_ydata()
- xs,ys,zs = juggle_axes(oxs,oys,self.zs,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- self._x = xs
- self._y = ys
- self.old_draw(renderer)
- self._x = oxs
- self._y = oys
-
-def wrap_line(line, zs,dir='z'):
- """Wrap a 2D line so that it draws as a 3D line"""
- line.zs = zs
- line.dir = dir
- line.old_draw = line.draw
- def wrapped_draw(renderer,line=line):
- return line_draw(line,renderer)
- line.draw = wrapped_draw
-
-def image_draw(image,renderer):
- source = image._A
- w,h,p = source.shape
- X,Y = meshgrid(arange(w),arange(h))
- Z = np.zeros((w,h))
- tX,tY,tZ = proj3d.transform(X.flat,Y.flat,Z.flat,M)
- tX = reshape(tX,(w,h))
- tY = reshape(tY,(w,h))
-
-def wrap_image(image, extent):
- image.extent3D = extent
- image.old_draw = image.draw
- def wrapped_draw(renderer,image=image):
- return image_draw(image,renderer)
- image.draw = wrapped_draw
-
-
-def set_line_data(line, xs,ys,zs):
- try: line = line[0]
- except: pass
- line.set_data(xs,ys)
- line.zs = zs
-
-def iscolor(c):
- try:
- return (len(c)==4 or len(c)==3) and (type(c[0])==float)
- except (IndexError):
- return None
-
-def get_colors(c, num):
- """Stretch the color argument to provide the required number num"""
- if type(c)==type("string"):
- c = colors.colorConverter.to_rgba(colors)
- if iscolor(c):
- return [c]*num
- elif iscolor(c[0]):
- return c*num
- elif len(c)==num:
- return c[:]
- else:
- raise ValueError, 'unknown color format %s' % c
-
-def zalpha(colors, zs):
- """Modify the alphas of the color list according to depth"""
- colors = get_colors(colors,len(zs))
- norm = Normalize(min(zs),max(zs))
- sats = 1 - norm(zs)*0.7
- colors = [(c[0],c[1],c[2],c[3]*s) for c,s in zip(colors,sats)]
- return colors
-
-def patch_draw(self, renderer):
- orig_offsets = self._offsets
- xs,ys = zip(*self._offsets)
- xs,ys,zs = juggle_axes(xs,ys,self.zs,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- # mess with colors
- orig_fcolors = self._facecolors
- orig_ecolors = self._edgecolors
- self._facecolors = zalpha(orig_fcolors,zs)
- self._edgecolors = zalpha(orig_ecolors,zs)
-
- self._offsets = zip(xs,ys)
- self.old_draw(renderer)
- self._offsets = orig_offsets
- self._facecolors = orig_fcolors
- self._edgecolors = orig_ecolors
-
-def wrap_patch(patch, zs, dir='z'):
- return Patch3DCollectionW(patch, zs, dir)
-
-def draw_linec(self, renderer):
- orig_segments = self._segments
- segments_3d = [[(x,y,z) for (x,y),z in zip(points,zs)]
- for zs, points in zip(self.zs, self._segments)]
- xyslist = [
- proj3d.proj_trans_points(points, renderer.M) for points in
- segments_3d]
- segments_2d = [zip(xs,ys) for (xs,ys,zs) in xyslist]
- self._segments = segments_2d
- LineCollection.draw(self, renderer)
- self._segments = orig_segments
-
-def draw_polyc(self, renderer):
- orig_segments = self._verts
- # process the list of lists of 2D points held in _verts to generate
- # a list of lists of 3D points
- segments_3d = [[(x,y,z) for (x,y),z in zip(points,self.zs)]
- for points in self._verts]
- #
- xyslist = [
- proj3d.proj_trans_points(points, renderer.M) for points in
- segments_3d]
- segments_2d = [zip(xs,ys) for (xs,ys,zs) in xyslist]
- self._verts = segments_2d
- PolyCollection.draw(self, renderer)
- self._verts = orig_segments
-
-def text_draw(self, renderer):
- x,y = self.get_position()
- xs,ys,zs = juggle_axes(x,y,self._z,self.dir)
- xs,ys,zs = proj3d.proj_transform(xs,ys,zs, renderer.M)
- self.set_x(xs)
- self.set_y(ys)
- self.old_draw(renderer)
- self.set_x(x)
- self.set_y(y)
-
-def wrap_text(text, zs, dir='z'):
- text._z = zs
- text.dir = dir
- text.old_draw = text.draw
- def wrapped_draw(renderer,text=text):
- return text_draw(text,renderer)
- text.draw = wrapped_draw
-
-def set_text_data(text, x,y,z):
- text._x,text._y,text._z = x,y,z
-
-def draw(text, renderer):
- print 'call draw text', text
- print text.get_visible()
- print 'text "%s"' % text._text
- res = text._get_layout(renderer)
- print res
- text._draw(renderer)
-
-def owrap(text):
- text._draw = text.draw
- def draw_text(renderer,text=text):
- draw(text,renderer)
- text.draw = draw_text
-
-def wrap_2d_fn(patch, zs,dir='z',fn=patch_draw):
- patch.zs = zs
- patch.dir = dir
- patch.old_draw = patch.draw
- def wrapped_draw(renderer,patch=patch,fn=fn):
- return fn(patch,renderer)
- patch.draw = wrapped_draw
- return patch
Modified: trunk/matplotlib/lib/matplotlib/axes3d.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/axes3d.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/lib/matplotlib/axes3d.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,835 +1 @@
-#!/usr/bin/python
-# axes3d.py
-#
-# Created: 23 Sep 2005
-#
-"""
-3D projection glued onto 2D Axes.
-
-Axes3D
-"""
-
-import random
-
-from axes import Axes
-import cbook
-from transforms import unit_bbox
-
-import numpy as np
-from colors import Normalize
-
-import art3d
-import proj3d
-import axis3d
-
-def sensible_format_data(self, value):
- """Used to generate more comprehensible numbers in status bar"""
- if abs(value) > 1e4 or abs(value)<1e-3:
- s = '%1.4e'% value
- return self._formatSciNotation(s)
- else:
- return '%4.3f' % value
-
-class Axes3DI(Axes):
- """Wrap an Axes object
-
- The x,y data coordinates, which are manipulated by set_xlim and
- set_ylim are used as the target view coordinates by the 3D
- transformations. These coordinates are mostly invisible to the
- outside world.
-
- set_w_xlim, set_w_ylim and set_w_zlim manipulate the 3D world
- coordinates which are scaled to represent the data and are stored
- in the xy_dataLim, zz_datalim bboxes.
-
- The axes representing the x,y,z world dimensions are self.w_xaxis,
- self.w_yaxis and self.w_zaxis. They can probably be controlled in
- more or less the normal ways.
- """
- def __init__(self, fig, rect=[0.0, 0.0, 1.0, 1.0], *args, **kwargs):
- self.fig = fig
-
- azim = cbook.popd(kwargs, 'azim', -60)
- elev = cbook.popd(kwargs, 'elev', 30)
-
- self.xy_viewLim = unit_bbox()
- self.zz_viewLim = unit_bbox()
- self.xy_dataLim = unit_bbox()
- self.zz_dataLim = unit_bbox()
- # inihibit autoscale_view until the axises are defined
- # they can't be defined until Axes.__init__ has been called
- self._ready = 0
- Axes.__init__(self, self.fig, rect,
- frameon=True,
- xticks=[], yticks=[], *args, **kwargs)
-
- self.M = None
- self._ready = 1
-
- self.view_init(elev, azim)
- self.mouse_init()
- self.create_axes()
- self.set_top_view()
-
- #self.axesPatch.set_edgecolor((1,0,0,0))
- self.axesPatch.set_linewidth(0)
- #self.axesPatch.set_facecolor((0,0,0,0))
- self.fig.add_axes(self)
-
- def set_top_view(self):
- # this happens to be the right view for the viewing coordinates
- # moved up and to the left slightly to fit labels and axes
- xdwl = (0.95/self.dist)
- xdw = (0.9/self.dist)
- ydwl = (0.95/self.dist)
- ydw = (0.9/self.dist)
- #
- self.set_xlim(-xdwl,xdw)
- self.set_ylim(-ydwl,ydw)
-
- def really_set_xlim(self, vmin, vmax):
- self.viewLim.intervalx().set_bounds(vmin, vmax)
-
- def really_set_ylim(self, vmin, vmax):
- self.viewLim.intervaly().set_bounds(vmin, vmax)
-
- def vlim_argument(self, get_lim, *args):
- if not args:
- vmin,vmax = get_lim()
- elif len(args)==2:
- vmin,vmax = args
- elif len(args)==1:
- vmin,vmax = args[0]
- return vmin,vmax
-
- def nset_xlim(self, *args):
- raise
- vmin,vmax = self.vlim_argument(self.get_xlim)
- print 'xlim', vmin,vmax
-
- def nset_ylim(self, *args):
- vmin,vmax = self.vlim_argument(self.get_ylim)
- print 'ylim', vmin,vmax
-
- def create_axes(self):
- self.w_xaxis = axis3d.Axis('x',self.xy_viewLim.intervalx,
- self.xy_dataLim.intervalx, self)
- self.w_yaxis = axis3d.Axis('y',self.xy_viewLim.intervaly,
- self.xy_dataLim.intervaly, self)
- self.w_zaxis = axis3d.Axis('z',self.zz_viewLim.intervalx,
- self.zz_dataLim.intervalx, self)
-
- def unit_cube(self,vals=None):
- minpy,maxx,miny,maxy,minz,maxz = vals or self.get_w_lims()
- xs,ys,zs = ([minpy,maxx,maxx,minpy,minpy,maxx,maxx,minpy],
- [miny,miny,maxy,maxy,miny,miny,maxy,maxy],
- [minz,minz,minz,minz,maxz,maxz,maxz,maxz])
- return zip(xs,ys,zs)
-
- def tunit_cube(self,vals=None,M=None):
- if M is None:
- M = self.M
- xyzs = self.unit_cube(vals)
- tcube = proj3d.proj_points(xyzs,M)
- return tcube
-
- def tunit_edges(self, vals=None,M=None):
- tc = self.tunit_cube(vals,M)
- edges = [(tc[0],tc[1]),
- (tc[1],tc[2]),
- (tc[2],tc[3]),
- (tc[3],tc[0]),
-
- (tc[0],tc[4]),
- (tc[1],tc[5]),
- (tc[2],tc[6]),
- (tc[3],tc[7]),
-
- (tc[4],tc[5]),
- (tc[5],tc[6]),
- (tc[6],tc[7]),
- (tc[7],tc[4])]
- return edges
-
- def draw(self, renderer):
- # draw the background patch
- self.axesPatch.draw(renderer)
- self._frameon = False
-
- # add the projection matrix to the renderer
- self.M = self.get_proj()
- renderer.M = self.M
- renderer.vvec = self.vvec
- renderer.eye = self.eye
- renderer.get_axis_position = self.get_axis_position
-
- #self.set_top_view()
- self.w_xaxis.draw(renderer)
- self.w_yaxis.draw(renderer)
- self.w_zaxis.draw(renderer)
- Axes.draw(self, renderer)
-
- def get_axis_position(self):
- vals = self.get_w_lims()
- tc = self.tunit_cube(vals,self.M)
- xhigh = tc[1][2]>tc[2][2]
- yhigh = tc[3][2]>tc[2][2]
- zhigh = tc[0][2]>tc[2][2]
- return xhigh,yhigh,zhigh
-
- def update_datalim(self, xys):
- pass
-
- def update_datalim_numerix(self, x, y):
- pass
-
- def auto_scale_xyz(self, X,Y,Z=None,had_data=None):
- x,y,z = map(np.asarray, (X,Y,Z))
- try:
- x,y = X.flat,Y.flat
- if Z is not None:
- z = Z.flat
- except AttributeError:
- pass
-
- self.xy_dataLim.update_numerix(x, y, not had_data)
- if z is not None:
- self.zz_dataLim.update_numerix(z, z, not had_data)
- self.autoscale_view()
-
- def autoscale_view(self, scalex=True, scaley=True, scalez=True):
- self.set_top_view()
- if not self._ready: return
-
- if not self._autoscaleon: return
-
- if scalex:
- locator = self.w_xaxis.get_major_locator()
- self.set_w_xlim(locator.autoscale())
- if scaley:
- locator = self.w_yaxis.get_major_locator()
- self.set_w_ylim(locator.autoscale())
- if scalez:
- locator = self.w_zaxis.get_major_locator()
- self.set_w_zlim(locator.autoscale())
-
- def get_w_lims(self):
- minpy,maxx = self.get_w_xlim()
- miny,maxy = self.get_w_ylim()
- minz,maxz = self.get_w_zlim()
- return minpy,maxx,miny,maxy,minz,maxz
-
- def set_w_zlim(self, *args, **kwargs):
- gl,self.get_xlim = self.get_xlim,self.get_w_zlim
- vl,self.viewLim = self.viewLim,self.zz_viewLim
- vmin,vmax = Axes.set_xlim(self, *args, **kwargs)
- self.get_xlim = gl
- self.viewLim = vl
- return vmin,vmax
-
- def set_w_xlim(self, *args, **kwargs):
- gl,self.get_xlim = self.get_xlim,self.get_w_xlim
- vl,self.viewLim = self.viewLim,self.xy_viewLim
- vmin,vmax = Axes.set_xlim(self, *args, **kwargs)
- self.get_xlim = gl
- self.viewLim = vl
- return vmin,vmax
-
- def set_w_ylim(self, *args, **kwargs):
- gl,self.get_ylim = self.get_ylim,self.get_w_ylim
- vl,self.viewLim = self.viewLim,self.xy_viewLim
- vmin,vmax = Axes.set_ylim(self, *args, **kwargs)
- self.get_ylim = gl
- self.viewLim = vl
- return vmin,vmax
-
- def get_w_zlim(self):
- return self.zz_viewLim.intervalx().get_bounds()
-
- def get_w_xlim(self):
- return self.xy_viewLim.intervalx().get_bounds()
-
- def get_w_ylim(self):
- return self.xy_viewLim.intervaly().get_bounds()
-
- def pany(self, numsteps):
- print 'numsteps', numsteps
-
- def panpy(self, numsteps):
- print 'numsteps', numsteps
-
- def view_init(self, elev, azim):
- self.dist = 10
- self.elev = elev
- self.azim = azim
-
- def get_proj(self):
- """Create the projection matrix from the current viewing
- position.
-
- elev stores the elevation angle in the z plane
- azim stores the azimuth angle in the x,y plane
-
- dist is the distance of the eye viewing point from the object
- point.
-
- """
- relev,razim = np.pi * self.elev/180, np.pi * self.azim/180
-
- xmin,xmax = self.get_w_xlim()
- ymin,ymax = self.get_w_ylim()
- zmin,zmax = self.get_w_zlim()
-
- # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0
- worldM = proj3d.world_transformation(xmin,xmax,
- ymin,ymax,
- zmin,zmax)
-
- # look into the middle of the new coordinates
- R = np.array([0.5,0.5,0.5])
- #
- xp = R[0] + np.cos(razim)*np.cos(relev)*self.dist
- yp = R[1] + np.sin(razim)*np.cos(relev)*self.dist
- zp = R[2] + np.sin(relev)*self.dist
-
- E = np.array((xp, yp, zp))
- #
- self.eye = E
- self.vvec = R - E
- self.vvec = self.vvec / proj3d.mod(self.vvec)
-
- if abs(relev) > np.pi/2:
- # upside down
- V = np.array((0,0,-1))
- else:
- V = np.array((0,0,1))
- zfront,zback = -self.dist,self.dist
-
- viewM = proj3d.view_transformation(E,R,V)
- perspM = proj3d.persp_transformation(zfront,zback)
- M0 = np.dot(viewM,worldM)
- M = np.dot(perspM,M0)
- return M
-
- def mouse_init(self):
- self.button_pressed = None
- if self.figure.canvas != None:
- self.figure.canvas.mpl_connect('motion_notify_event', self.on_move)
- self.figure.canvas.mpl_connect('button_press_event', self.button_press)
- self.figure.canvas.mpl_connect('button_release_event', self.button_release)
-
- def button_press(self, event):
- self.button_pressed = event.button
- self.sx,self.sy = event.xdata,event.ydata
-
- def button_release(self, event):
- self.button_pressed = None
-
- def format_xdata(self, x):
- """
- Return x string formatted. This function will use the attribute
- self.fmt_xdata if it is callable, else will fall back on the xaxis
- major formatter
- """
- try: return self.fmt_xdata(x)
- except TypeError:
- fmt = self.w_xaxis.get_major_formatter()
- return sensible_format_data(fmt,x)
-
- def format_ydata(self, y):
- """
- Return y string formatted. This function will use the attribute
- self.fmt_ydata if it is callable, else will fall back on the yaxis
- major formatter
- """
- try: return self.fmt_ydata(y)
- except TypeError:
- fmt = self.w_yaxis.get_major_formatter()
- return sensible_format_data(fmt,y)
-
- def format_zdata(self, z):
- """
- Return y string formatted. This function will use the attribute
- self.fmt_ydata if it is callable, else will fall back on the yaxis
- major formatter
- """
- try: return self.fmt_zdata(z)
- except (AttributeError,TypeError):
- fmt = self.w_zaxis.get_major_formatter()
- return sensible_format_data(fmt,z)
-
- def format_coord(self, xd, yd):
- """Given the 2D view coordinates attempt to guess a 3D coordinate
-
- Looks for the nearest edge to the point and then assumes that the point is
- at the same z location as the nearest point on the edge.
- """
-
- if self.button_pressed == 1:
- return 'azimuth=%d deg, elevation=%d deg ' % (self.azim, self.elev)
- # ignore xd and yd and display angles instead
-
- p = (xd,yd)
- edges = self.tunit_edges()
- #lines = [proj3d.line2d(p0,p1) for (p0,p1) in edges]
- ldists = [(proj3d.line2d_seg_dist(p0,p1,p),i) for i,(p0,p1) in enumerate(edges)]
- ldists.sort()
- # nearest edge
- edgei = ldists[0][1]
- #
- p0,p1 = edges[edgei]
-
- # scale the z value to match
- x0,y0,z0 = p0
- x1,y1,z1 = p1
- d0 = np.hypot(x0-xd,y0-yd)
- d1 = np.hypot(x1-xd,y1-yd)
- dt = d0+d1
- z = d1/dt * z0 + d0/dt * z1
- #print 'mid', edgei, d0, d1, z0, z1, z
-
- x,y,z = proj3d.inv_transform(xd,yd,z,self.M)
-
- xs = self.format_xdata(x)
- ys = self.format_ydata(y)
- zs = self.format_ydata(z)
- return 'x=%s, y=%s, z=%s'%(xs,ys,zs)
-
- def on_move(self, event):
- """Mouse moving
-
- button-1 rotates
- button-3 zooms
- """
- if not self.button_pressed:
- return
-
- if self.M is None:
- return
- # this shouldn't be called before the graph has been drawn for the first time!
-
- x, y = event.xdata, event.ydata
- dx,dy = x-self.sx,y-self.sy
- x0,x1 = self.get_xlim()
- y0,y1 = self.get_ylim()
- w = (x1-x0)
- h = (y1-y0)
- self.sx,self.sy = x,y
-
- if self.button_pressed == 1:
- # rotate viewing point
- # get the x and y pixel coords
- if dx == 0 and dy == 0: return
- #
- self.elev = axis3d.norm_angle(self.elev - (dy/h)*180)
- self.azim = axis3d.norm_angle(self.azim - (dx/w)*180)
- self.get_proj()
- self.figure.canvas.draw()
- elif self.button_pressed == 2:
- # pan view
- # project xv,yv,zv -> xw,yw,zw
- # pan
- #
- pass
- elif self.button_pressed == 3:
- # zoom view
- # hmmm..this needs some help from clipping....
- minpy,maxx,miny,maxy,minz,maxz = self.get_w_lims()
- df = 1-((h - dy)/h)
- dx = (maxx-minpy)*df
- dy = (maxy-miny)*df
- dz = (maxz-minz)*df
- self.set_w_xlim(minpy-dx,maxx+dx)
- self.set_w_ylim(miny-dy,maxy+dy)
- self.set_w_zlim(minz-dz,maxz+dz)
- self.get_proj()
- self.figure.canvas.draw()
-
- def set_xlabel(self, xlabel, fontdict=None, **kwargs):
- #par = cbook.popd(kwargs, 'par',None)
- #label.set_par(par)
- #
- label = self.w_xaxis.get_label()
- label.set_text(xlabel)
- if fontdict is not None: label.update(fontdict)
- label.update(kwargs)
- return label
-
- def set_ylabel(self, ylabel, fontdict=None, **kwargs):
- label = self.w_yaxis.get_label()
- label.set_text(ylabel)
- if fontdict is not None: label.update(fontdict)
- label.update(kwargs)
- return label
-
- def set_zlabel(self, zlabel, fontdict=None, **kwargs):
- label = self.w_zaxis.get_label()
- label.set_text(zlabel)
- if fontdict is not None: label.update(fontdict)
- label.update(kwargs)
- return label
-
- def plot(self, *args, **kwargs):
- had_data = self.has_data()
-
- zval = cbook.popd(kwargs, 'z', 0)
- zdir = cbook.popd(kwargs, 'dir', 'z')
- lines = Axes.plot(self, *args, **kwargs)
- #
- linecs = [art3d.Line2DW(l, z=zval, dir=zdir) for l in lines]
- #
- xs = lines[0].get_xdata()
- ys = lines[0].get_ydata()
- zs = [zval for x in xs]
- xs,ys,zs = art3d.juggle_axes(xs,ys,zs,zdir)
- #
- self.auto_scale_xyz(xs,ys,zs, had_data)
- #
- return linecs
-
- def plot3D(self, xs, ys, zs, *args, **kwargs):
- had_data = self.has_data()
- lines = Axes.plot(self, xs,ys, *args, **kwargs)
- if len(lines)==1:
- line = lines[0]
- art3d.wrap_line(line, zs)
- #
- self.auto_scale_xyz(xs,ys,zs, had_data)
- return lines
-
- plot3d=plot3D
-
- def plot_surface(self, X, Y, Z, *args, **kwargs):
- had_data = self.has_data()
-
- rows, cols = Z.shape
- tX,tY,tZ = np.transpose(X), np.transpose(Y), np.transpose(Z)
- rstride = cbook.popd(kwargs, 'rstride', 10)
- cstride = cbook.popd(kwargs, 'cstride', 10)
- #
- polys = []
- boxes = []
- for rs in np.arange(0,rows-1,rstride):
- for cs in np.arange(0,cols-1,cstride):
- ps = []
- corners = []
- for a,ta in [(X,tX),(Y,tY),(Z,tZ)]:
- ztop = a[rs][cs:min(cols,cs+cstride+1)]
- zleft = ta[min(cols-1,cs+cstride)][rs:min(rows,rs+rstride+1)]
- zbase = a[min(rows-1,rs+rstride)][cs:min(cols,cs+cstride+1):]
- zbase = zbase[::-1]
- zright = ta[cs][rs:min(rows,rs+rstride+1):]
- zright = zright[::-1]
- corners.append([ztop[0],ztop[-1],zbase[0],zbase[-1]])
- z = np.concatenate((ztop,zleft,zbase,zright))
- ps.append(z)
- boxes.append(map(np.array,zip(*corners)))
- polys.append(zip(*ps))
- #
- lines = []
- shade = []
- for box in boxes:
- n = proj3d.cross(box[0]-box[1],
- box[0]-box[2])
- n = n/proj3d.mod(n)*5
- shade.append(np.dot(n,[-1,-1,0.5]))
- lines.append((box[0],n+box[0]))
- #
- color = np.array([0,0,1,1])
- norm = Normalize(min(shade),max(shade))
- colors = [color * (0.5+norm(v)*0.5) for v in shade]
- for c in colors: c[3] = 1
- polyc = art3d.Poly3DCollection(polys, facecolors=colors, *args, **kwargs)
- polyc._zsort = 1
- self.add_collection(polyc)
- #
- self.auto_scale_xyz(X,Y,Z, had_data)
- return polyc
-
- def plot_wireframe(self, X, Y, Z, *args, **kwargs):
- rstride = cbook.popd(kwargs, "rstride", 1)
- cstride = cbook.popd(kwargs, "cstride", 1)
-
- had_data = self.has_data()
- rows,cols = Z.shape
-
- tX,tY,tZ = np.transpose(X), np.transpose(Y), np.transpose(Z)
-
- rii = [i for i in range(0,rows,rstride)]+[rows-1]
- cii = [i for i in range(0,cols,cstride)]+[cols-1]
- xlines = [X[i] for i in rii]
- ylines = [Y[i] for i in rii]
- zlines = [Z[i] for i in rii]
- #
- txlines = [tX[i] for i in cii]
- tylines = [tY[i] for i in cii]
- tzlines = [tZ[i] for i in cii]
- #
- lines = [zip(xl,yl,zl) for xl,yl,zl in zip(xlines,ylines,zlines)]
- lines += [zip(xl,yl,zl) for xl,yl,zl in zip(txlines,tylines,tzlines)]
- linec = self.add_lines(lines, *args, **kwargs)
-
- self.auto_scale_xyz(X,Y,Z, had_data)
- return linec
-
- def contour3D(self, X, Y, Z, *args, **kwargs):
- had_data = self.has_data()
- cset = self.contour(X, Y, Z, *args, **kwargs)
- for z,linec in zip(cset.levels,cset.collections):
- zl = []
- linew = art3d.Line2DCollectionW(linec, z)
- self.auto_scale_xyz(X,Y,Z, had_data)
- return cset
-
- def clabel(self, *args, **kwargs):
- r = Axes.clabel(self, *args, **kwargs)
- return r
-
- def contourf3D(self, X, Y, Z, *args, **kwargs):
- raise NotImplementedError("contourf3D is broken")
- had_data = self.has_data()
-
- cset = self.contourf(X, Y, Z, *args, **kwargs)
- levels = cset.levels
- colls = cset.collections
- for z1,z2,linec in zip(levels,levels[1:],colls):
- zs = [z1] * (len(linec._verts[0])/2)
- zs += [z2] * (len(linec._verts[0])/2)
- # The following is clearly wrong.
- art3d.wrap_patch(linec, zs, fn=art3d.draw_polyc)
- self.auto_scale_xyz(X,Y,Z, had_data)
- return cset
-
- def scatter3D(self, xs, ys, zs, *args, **kwargs):
- had_data = self.has_data()
- patches = Axes.scatter(self,xs,ys,*args,**kwargs)
- patches = art3d.wrap_patch(patches, zs)
- #
- self.auto_scale_xyz(xs,ys,zs, had_data)
- return patches
- scatter3d = scatter3D
-
- def add_lines(self, lines, *args, **kwargs):
- linec = art3d.Line3DCollection(lines, *args, **kwargs)
- self.add_collection(linec)
- return linec
-
- def text3D(self, x,y,z,s, *args, **kwargs):
- text = Axes.text(self,x,y,s,*args,**kwargs)
- art3d.wrap_text(text,z)
- return text
-
- def ahvline(self, x,y):
- pass
-
- def ahvxplane(self, x):
- pass
-
- def ahvyplane(self, y):
- pass
-
-class Scaler:
- def __init__(self, points):
- self.inpoints = points
- self.drawpoints = None
-
- def update(self, lims):
- for x,y,z in self.points:
- pass
-
-class Axes3D:
- """
- Wrapper for Axes3DI
-
- Provides set_xlim, set_ylim etc.
-
- 2D functions can be caught here and mapped
- to their 3D approximations.
-
- This should probably be the case for plot etc...
- """
- def __init__(self, fig, *args, **kwargs):
- self.__dict__['wrapped'] = Axes3DI(fig, *args, **kwargs)
-
- def set_xlim(self, *args, **kwargs):
- self.wrapped.set_w_xlim(*args, **kwargs)
-
- def set_ylim(self, *args, **kwargs):
- self.wrapped.set_w_ylim(*args, **kwargs)
-
- def set_zlim(self, *args, **kwargs):
- self.wrapped.set_w_zlim(*args, **kwargs)
-
- def __getattr__(self, k):
- return getattr(self.wrapped,k)
-
- def __setattr__(self, k,v):
- return setattr(self.wrapped,k,v)
-
- def add_collection(self, polys, zs=None, dir='z'):
- patches = art3d.Poly3DCollectionW(polys, zs=zs,dir=dir)
- self.add_3DCollection(patches)
-
- def add_3DCollection(self, patches):
- self.wrapped.add_collection(patches)
-
- def text(self, x,y, text, *args,**kwargs):
- self.wrapped.text3D(x,y,0,text,*args,**kwargs)
-
- def scatter(self, xs,ys,zs=None,dir='z',*args,**kwargs):
- patches = self.wrapped.scatter(xs,ys,*args,**kwargs)
- if zs is None:
- zs = [0]*len(xs)
- patches = art3d.wrap_patch(patches, zs=zs, dir=dir)
- return patches
-
- def bar(self, left, height, z=0, dir='z', *args, **kwargs):
- had_data = self.has_data()
- patches = self.wrapped.bar(left, height, *args, **kwargs)
- #
- verts = []
- for p in patches:
- vs = p.get_verts()
- zs = [z]*len(vs)
- verts += vs
- patch3d = art3d.Patch3D(p, zs, dir=dir)
- xs,ys = zip(*verts)
- zs = [z]*len(xs)
- xs,ys,zs=art3d.juggle_axes(xs,ys,zs,dir)
- self.wrapped.auto_scale_xyz(xs,ys,zs, had_data)
-
-def test_scatter():
-
- ax = Axes3D()
- #
- #
- n = 100
- for c,zl,zh in [('r',-50,-25),('b',-30,-5)]:
- xs,ys,zs = zip(*
- [(random.randrange(23,32),
- random.randrange(100),
- random.randrange(zl,zh)
- ) for i in range(n)])
- ax.scatter3D(xs,ys,zs, c=c)
- #
- ax.set_xlabel('------------ X Label --------------------')
- ax.set_ylabel('------------ Y Label --------------------')
- ax.set_zlabel('------------ Z Label --------------------')
-
-def get_test_data(delta=0.05):
- from mlab import bivariate_normal
- x = y = np.arange(-3.0, 3.0, delta)
- X, Y = np.meshgrid(x,y)
-
- Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
- Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
- Z = Z2-Z1
-
- X = X * 10
- Y = Y * 10
- Z = Z * 500
- return X,Y,Z
-
-def test_wire():
- ax = Axes3D()
-
- X,Y,Z = get_test_data(0.05)
- ax.plot_wireframe(X,Y,Z, rstride=10,cstride=10)
- #
- ax.set_xlabel('X')
- ax.set_ylabel('Y')
- ax.set_zlabel('Z')
-
-def test_surface():
- ax = Axes3D()
-
- X,Y,Z = get_test_data(0.05)
- ax.plot_surface(X,Y,Z, rstride=10,cstride=10)
- #
- ax.set_xlabel('X')
- ax.set_ylabel('Y')
- ax.set_zlabel('Z')
-
-
-def test_contour():
- ax = Axes3D()
-
- X,Y,Z = get_test_data(0.05)
- cset = ax.contour3D(X,Y,Z)
- ax.clabel(cset, fontsize=9, inline=1)
- #
- ax.set_xlabel('X')
- ax.set_ylabel('Y')
- ax.set_zlabel('Z')
-
-def test_plot():
- ax = Axes3D()
- xs = np.arange(0,4*np.pi+0.1,0.1)
- ys = np.sin(xs)
- ax.plot(xs,ys, label='zl')
- ax.plot(xs,ys+max(xs),label='zh')
- ax.plot(xs,ys,dir='x', label='xl')
- ax.plot(xs,ys,dir='x', z=max(xs),label='xh')
- ax.plot(xs,ys,dir='y', label='yl')
- ax.plot(xs,ys,dir='y', z=max(xs), label='yh')
- ax.set_xlabel('X')
- ax.set_ylabel('Y')
- ax.set_zlabel('Z')
- ax.legend()
-
-
-def test_polys():
- from matplotlib.collections import LineCollection, PolyCollection
- from matplotlib.colors import colorConverter
-
- cc = lambda arg: colorConverter.to_rgba(arg, alpha=0.6)
-
- ax = Axes3D()
- xs = np.arange(0,10,0.4)
- verts = []
- zs = [0.0,1.0,2.0,3.0]
- for z in zs:
- ys = [random.random() for x in xs]
- ys[0],ys[-1] = 0,0
- verts.append(zip(xs,ys))
-
- poly = PolyCollection(verts, facecolors = [cc('r'),cc('g'),cc('b'),
- cc('y')])
- #patches = art3d.Poly3DCollectionW(poly, zs=zs, dir='y')
- #poly = PolyCollection(verts)
- ax.add_collection(poly,zs=zs,dir='y')
- #ax.wrapped.add_collection(poly)
- #
- ax.plot(xs,ys, z=z, dir='y', c='r')
- ax.set_xlim(0,10)
- ax.set_ylim(-1,4)
- ax.set_zlim(0,1)
-
-def test_scatter2D():
- xs = [random.random() for i in range(20)]
- ys = [random.random() for x in xs]
- ax = Axes3D()
- ax.scatter(xs,ys)
- ax.scatter(xs,ys, dir='y', c='r')
- ax.scatter(xs,ys, dir='x', c='g')
-
-def test_bar2D():
- ax = Axes3D()
-
- for c,z in zip(['r','g','b','y'],[30,20,10,0]):
- xs = np.arange(20)
- ys = [random.random() for x in xs]
- ax.bar(xs,ys,z=z,dir='y',color=c)
- #ax.plot(xs,ys)
-
-if __name__ == "__main__":
- import pylab
- #test_scatter()
- #test_wire()
- #test_surface()
- #test_contour()
- #test_plot()
- test_polys()
- #test_scatter2D()
- test_bar2D()
- pylab.show()
+raise NotImplmentedError('axes3d is not supported in matplotlib-0.98. You may want to try the 0.91.x maintenance branch')
Deleted: trunk/matplotlib/lib/matplotlib/axis3d.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/axis3d.py 2008-06-22 08:19:56 UTC (rev 5628)
+++ trunk/matplotlib/lib/matplotlib/axis3d.py 2008-06-22 13:52:43 UTC (rev 5629)
@@ -1,394 +0,0 @@
-#!/usr/bin/python
-# axis3d.py
-#
-# Created: 23 Sep 2005
-
-import math
-
-import lines
-import axis
-import patches
-import text
-
-import art3d
-import proj3d
-
-import numpy as np
-
-def norm_angle(a):
- """Return angle between -180 and +180"""
- a = (a+360)%360
- if a > 180: a = a-360
- return a
-
-def text_update_coords(self, renderer):
- """Modified method update_coords from TextWithDash
-
- I could not understand the original text offset calculations and
- it gave bad results for the angles I was using. This looks
- better, although the text bounding boxes look a little
- inconsistent
- """
-
- (x, y) = self.get_position()
- dashlength = self.get_dashlength()
-
- # Shortcircuit this process if we don't have a dash
- if dashlength == 0.0:
- self._mytext.set_position((x, y))
- return
-
- dashrotation = self.get_dashrotation()
- dashdirection = self.get_dashdirection()
- dashpad = self.get_dashpad()
- dashpush = self.get_dashpush()
- transform = self.get_transform()
-
- angle = text.get_rotation(dashrotation)
-
- theta = math.pi*(angle/180.0+dashdirection-1)
- cos_theta, sin_theta = math.cos(theta), math.sin(theta)
-
- # Compute the dash end points
- # The 'c' prefix is for canvas coordinates
- cxy = np.array(transform.xy_tup((x, y)))
- cd = np.array([cos_theta, sin_theta])
- c1 = cxy+dashpush*cd
- c2 = cxy+(dashpush+dashlength)*cd
- (x1, y1) = transform.inverse_xy_tup(tuple(c1))
- (x2, y2) = transform.inverse_xy_tup(tuple(c2))
- self.dashline.set_data((x1, x2), (y1, y2))
-
- # We now need to extend this vector out to
- # the center of the text area.
- # The basic problem here is that we're "rotating"
- # two separate objects but want it to appear as
- # if they're rotated together.
- # This is made non-trivial because of the
- # interaction between text rotation and alignment -
- # text alignment is based on the bbox after rotation.
- # We reset/force both alignments to 'center'
- # so we can do something relatively reasonable.
- # There's probably a better way to do this by
- # embedding all this in the object's transformations,
- # but I don't grok the transformation stuff
- # well enough yet.
- we = self._mytext.get_window_extent(renderer=renderer)
- w, h = we.width(), we.height()
- off = np.array([cos_theta*(w/2+2)-1,sin_theta*(h+1)-1])
- off = np.array([cos_theta*(w/2),sin_theta*(h/2)])
- dir = np.array([cos_theta,sin_theta])*dashpad
- cw = c2 + off +dir
-
- self._mytext.set_position(transform.inverse_xy_tup(tuple(cw)))
- # Now set the window extent
- # I'm not at all sure this is the right way to do this.
- we = self._mytext.get_window_extent(renderer=renderer)
- self._window_extent = we.deepcopy()
- self._window_extent.update(((c1[0], c1[1]),), False)
-
- # Finally, make text align center
- self._mytext.set_horizontalalignment('center')
- self._mytext.set_verticalalignment('center')
-
-def tick_update_position(tick, x,y,z, angle):
- #
- tick.tick1On = False
- tick.tick2On = False
- tick.tick1line.set_data((x, x),(y,y))
- tick.tick2line.set_data((x, x),(y,y))
- tick.gridline.set_data((x, x),(y,y))
- #
- tick.label1.set_dashlength(8)
- tick.label1.set_dashrotation(angle)
- tick.label1.set_position((x,y))
- tick.label2.set_position((x,y))
-
-class Axis(axis.XAxis):
- def __init__(self, adir, v_intervalx, d_intervalx, axes, *args, **kwargs):
- # adir identifies which axes this is
- self.adir = adir
- # data and viewing intervals for this direction
- self.d_interval = d_intervalx
- self.v_interval = v_intervalx
- #
- axis.XAxis.__init__(self, axes, *args, **kwargs)
- self.line = lines.Line2D(xdata=(0,0),ydata=(0,0),
- linewidth=0.75,
- color=(0,0,0,0),
- antialiased=True,
- )
- #
- # these are the panes which surround the boundary of the view
- self.pane_bg_color = (0.95,0.95,0.95,0.1)
- self.pane_fg_color = (0.9,0.9,0.9,0.5)
- self.pane = patches.Polygon([],
- alpha=0.2,
- facecolor=self.pane_fg_color,
- edgecolor=self.pane_fg_color)
- #
- self.axes._set_artist_props(self.line)
- self.axes._set_artist_props(self.pane)
- self.gridlines = art3d.Line3DCollection([])
- self.axes._set_artist_props(self.gridlines)
- self.axes._set_artist_props(self.label)
- self.label._transform = self.axes.transData
-
- def get_tick_positions(self):
- majorTicks = self.get_major_ticks()
- majorLocs = self.major.locator()
- self.major.formatter.set_locs(majorLocs)
- majorLabels = [self.major.formatter(val, i) for i, val in enumerate(majorLocs)]
- return majorLabels,majorLocs
-
- def get_major_ticks(self):
- ticks = axis.XAxis.get_major_ticks(self)
- for t in ticks:
- def update_coords(renderer,self=t.label1):
- return text_update_coords(self, renderer)
- # Text overrides setattr so need this to force new method
- #t.label1.__dict__['update_coords'] = update_coords
- t.tick1line.set_transform(self.axes.transData)
- t.tick2line.set_transform(self.axes.transData)
- t.gridline.set_transform(self.axes.transData)
- t.label1.set_transform(self.axes.transData)
- t.label2.set_transform(self.axes.transData)
- #
- return ticks
-
- def set_pane_fg(self, xys):
- self.pane.xy = xys
- self.pane.set_edgecolor(self.pane_fg_color)
- self.pane.set_facecolor(self.pane_fg_color)
- self.pane.set_alpha(self.pane_fg_color[-1])
-
- def set_pane_bg(self, xys):
- self.pane.xy = xys
- self.pane.set_edgecolor(self.pane_bg_color)
- self.pane.set_facecolor(self.pane_bg_color)
- self.pane.set_alpha(self.pane_bg_color[-1])
-
- def draw(self, renderer):
- #
- self.label._transform = self.axes.transData
- renderer.open_group('axis3d')
- ticklabelBoxes = []
- ticklabelBoxes2 = []
-
- # code from XAxis
- majorTicks = self.get_major_ticks()
- majorLocs = self.major.locator()
- self.major.formatter.set_locs(majorLocs)
- majorLabels = [self.major.formatter(val, i)
- for i, val in enumerate(majorLocs)]
- #
- minx,maxx,miny,maxy,minz,maxz = self.axes.get_w_lims()
-
- interval = self.get_view_interval()
- # filter locations here so that no extra grid lines are drawn
- majorLocs = [loc for loc in majorLocs if interval.contains(loc)]
- # these will generate spacing for labels and ticks
- dx = (maxx-minx)/12
- dy = (maxy-miny)/12
- dz = (maxz-minz)/12
-
- # stretch the boundary slightly so that the ticks have a better fit
- minx,maxx,miny,maxy,minz,maxz = (
- minx-dx/4,maxx+dx/4,miny-dy/4,maxy+dy/4,minz-dz/4,maxz+dz/4)
-
- # generate the unit_cubes and transformed unit_cubes from the stretched
- # limits
- vals = minx,maxx,miny,maxy,minz,maxz
- uc = self.axes.unit_cube(vals)
- tc = self.axes.tunit_cube(vals,renderer.M)
- #
- # these are flags which decide whether the axis should be drawn
- # on the high side (ie on the high side of the paired axis)
- xhigh = tc[1][2]>tc[2][2]
- yhigh = tc[3][2]>tc[2][2]
- zhigh = tc[0][2]>tc[2][2]
- #
- aoff = 0
-
- # lx,ly,lz are the label positions in user coordinates
- # to and te are the locations of the origin and the end of the axis
- #
- if self.adir == 'x':
- lx = (minx+maxx)/2
- if xhigh:
- # xaxis at front
- self.set_pane_fg([tc[0],tc[1],tc[5],tc[4]])
- to = tc[3]
- te = tc[2]
- xyz = [(x,maxy,minz) for x in majorLocs]
- nxyz = [(x,miny,minz) for x in majorLocs]
- lxyz = [(x,miny,maxz) for x in majorLocs]
- aoff = -90
-
- ly = maxy + dy
- lz = minz - dz
- else:
- self.set_pane_bg([tc[3],tc[2],tc[6],tc[7]])
- to = tc[0]
- te = tc[1]
- xyz = [(x,miny,minz) for x in majorLocs]
- nxyz = [(x,maxy,minz) for x in majorLocs]
- lxyz = [(x,maxy,maxz) for x in majorLocs]
- aoff = 90
-
- ly = miny - dy
- lz = minz - dz
-
- elif self.adir == 'y':
- # cube 3 is minx,maxy,minz
- # cube 2 is maxx,maxy,minz
- ly = (maxy+miny)/2
- if yhigh:
- # yaxis at front
- self.set_pane_fg([tc[0],tc[3],tc[7],tc[4]])
- to = tc[1]
- te = tc[2]
- xyz = [(maxx,y,minz) for y in majorLocs]
- nxyz = [(minx,y,minz) for y in majorLocs]
- lxyz = [(minx,y,maxz) for y in majorLocs]
- aoff = 90
-
- #
- lx = maxx + dx
- lz = minz - dz
-
- else:
- # yaxis at back
- self.set_pane_bg([tc[1],tc[5],tc[6],tc[2]])
- to = tc[0]
- te = tc[3]
- xyz = [(minx,y,minz) for y in majorLocs]
- nxyz = [(maxx,y,minz) for y in majorLocs]
- lxyz = [(maxx,y,maxz) for y in majorLocs]
- aoff = -90
- #
- lx = minx - dx
- lz = minz - dz
-
- elif self.adir == 'z':
- nxyz = None
- self.set_pane_bg([tc[0],tc[1],tc[2],tc[3]])
- aoff = -90
- lz = (maxz+minz)/2
- if xhigh and yhigh:
- to = tc[1]
- te = tc[5]
- xyz = [(maxx,miny,z) for z in majorLocs]
- nxyz = [(minx,miny,z) for z in ma...
[truncated message content] |
