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] |