Menu
▾
▴
matplotlib-devel
|
From: Thane <th...@ma...> - 2004-11-04 22:31:05
Attachments:
__init__.py
_backend_dotnet.pyd
|
"""
backend_dotnet.py
A .NET backend for matplotlib, based on backend_template.py and=0A=
various other backends.
=0A=
Author: Thane Plummer (th...@ma...)
=20
This module requires that .NET be installed on the computer.
=20
License: This work is licensed under a PSF compatible license. A copy=0A=
should be included with this source code.
=20
History:
0.2.4 11/04/04 Added dashstyle parsing for lines.=20
0.2.3 11/04/04 Fixed draw_arc coordinates and fill.
0.2.2 11/04/04 Fixed colors; all coord xform now done in Python.
0.2.1 11/03/04 Fixed GraphicsContext parsing to the .NET DLL.
0.2.0 11/01/04 Created a DLL for the backend. Should work with =
any .NET machine.
0.1.1 10/21/04 Added threading for interactive use from command =
line.
0.1.0 08/15/04 Initial coding in PythonNet. Needs some tweaking, =
but most of it works.=0A=
=0A=
"""
__version__ =3D "0.2.4"=0A=
=0A=
import sys
import math
import matplotlib=0A=
from matplotlib._matlab_helpers import Gcf=0A=
from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \=0A=
FigureManagerBase, FigureCanvasBase, error_msg=0A=
=0A=
from matplotlib.cbook import enumerate, True, False=0A=
from matplotlib.figure import Figure=0A=
from matplotlib.transforms import Bbox
from matplotlib.colors import ColorConverter
# .NET Graphics imports
import _backend_dotnet as dotnet
=0A=
# the true dots per inch on the screen; should be display dependent=0A=
# see =
http://groups.google.com/groups?q=3Dscreen+dpi+x11&hl=3Den&lr=3D&ie=3DUTF=
-8&oe=3DUTF-8&safe=3Doff&selm=3D7077.26e81ad5%40swift.cs.tcd.ie&rnum=3D5 =
for some info about screen dpi=0A=
PIXELS_PER_INCH =3D 75=0A=
=0A=
def error_msg_dotnet(msg, *args):=0A=
"""=0A=
Signal an error condition -- in a GUI, popup a error dialog=0A=
"""=0A=
print >>sys.stderr, 'Error:', msg
#WinForms.MessageBox.Show("Error", msg)=0A=
#sys.exit() # Errors should not be fatal in .NET=0A=
=0A=
class RendererDotNet(RendererBase):=0A=
"""=0A=
The renderer handles all the drawing primitives using a graphics=0A=
context instance that controls the colors/styles=0A=
"""
=20
def __init__(self, width, height):
self.height =3D int(height)
self.width =3D int(width)
self.form =3D dotnet.create_form(self.width, self.height)
=20
def show(self):
dotnet.show()=0A=
=0A=
def get_canvas_width_height(self):=0A=
'return the canvas width and height in display coords'=0A=
return self.width, self.height =0A=
=0A=
def get_text_width_height(self, s, fontsize, ismath=3DFalse):=0A=
"""=0A=
get the width and height in display coords of the string s=0A=
with fontsize in points
fontsize =3D (['Lucida Grande', 'Verdana', 'Geneva', 'Lucida', =
'Bitstream Vera Sans', 'Arial', 'Helvetica', 'sans-serif'], 'normal', =
'normal', 'medium', 'normal', 12.0)=0A=
"""
w =3D len(s)*5
if isinstance(fontsize, tuple):
h =3D fontsize[-1]
else:
h =3D 12=0A=
return w, h
=0A=
def flipy(self):=0A=
'return true if y small numbers are top for renderer'=0A=
return True=0A=
=0A=
def draw_text(self, gc, x, y, s, prop, angle, ismath=3DFalse): =0A=
"""=0A=
Render the matplotlib.text.Text instance at x, y in window=0A=
coords using GraphicsContext gc=0A=
"""
# Note: prop is a class 'instance' -- NOT a tuple
# prop =3D (['Lucida Grande', 'Verdana', 'Geneva', 'Lucida', =
'Bitstream Vera Sans', 'Arial', 'Helvetica', 'sans-serif'], 'normal', =
'normal', 'medium', 'normal', 14.0)
# See font_manager.py FontProperties class for more methods
fontsize =3D prop.get_size()
if not isinstance(fontsize, int) or not isinstance(fontsize, =
float):
fontsize =3D 10 # ToDo: support the prop.size =
option in .NET
fontfamily =3D prop.get_family()
fontname =3D fontfamily[0]
x =3D x - 1 # this one pixel seems to help
y =3D int(y - fontsize - 1) # this one pixel seems to help
angle =3D -angle
dotnet.draw_text(gc.gc_tuple(), x, y, s, fontname, fontsize, =
angle)
=0A=
=0A=
def draw_arc(self, gcEdge, rgbFace, x, y, width, height, angle1, =
angle2):=0A=
"""=0A=
Draw an arc centered at x,y with width and height and angles=0A=
from 0.0 to 360.0.=0A=
=0A=
If rgbFace is not None, fill the arc with it. gcEdge=0A=
is a GraphicsContext instance=0A=
"""
ulX =3D x - width/2.0=0A=
ulY =3D self.height - y - (height/2.0)
if rgbFace:
dotnet.fill_arc(rgbFace, ulX, ulY, width, height)
dotnet.draw_arc(gcEdge.gc_tuple(), ulX, ulY, width, height, =
angle1, angle2)
=0A=
=0A=
def draw_line(self, gc, x1, y1, x2, y2):=0A=
"""=0A=
Draw a single line from x1,y1 to x2,y2=0A=
"""
dotnet.draw_line(gc.gc_tuple(), x1, self.height - y1, x2, =
self.height - y2)=0A=
=0A=
def draw_lines(self, gc, x, y):=0A=
"""=0A=
x and y are equal length arrays, draw lines connecting each=0A=
point in x, y=0A=
"""
# Morph the points for .NET graphics -- .NET method uses (x,y) =
for upper left
height =3D self.height # does this increase the speed?
ulY =3D [height - yval for yval in y]
dotnet.draw_lines(gc.gc_tuple(), x, ulY)=0A=
=0A=
def draw_polygon(self, gcEdge, rgbFace, points):=0A=
"""=0A=
Draw a polygon. points is a len vertices tuple, each element=0A=
giving the x,y coords a vertex.=0A=
=0A=
If rgbFace is not None, fill the rectangle with it. gcEdge=0A=
is a GraphicsContext instance=0A=
"""=20
# Hack to fix point structure -- .NET method uses (x,y) for =
upper left
xvals =3D [x for x,y in points]
yvals =3D [self.height - y for x,y in points]
if rgbFace:
dotnet.fill_polygon(rgbFace, xvals, yvals)
dotnet.draw_polygon(gcEdge.gc_tuple(), xvals, yvals)=0A=
=0A=
def draw_rectangle(self, gcEdge, rgbFace, x, y, width, height):=0A=
"""=0A=
Draw a rectangle at lower left x,y with width and height.=0A=
=0A=
If rgbFace is not None, fill the rectangle with it. gcEdge=0A=
is a GraphicsContext instance=0A=
"""
if rgbFace:
dotnet.fill_rectangle(rgbFace, x, self.height - =
(self.height+y), width, height)
dotnet.draw_rectangle(gcEdge, x, self.height - (self.height+y), =
width, height)
=0A=
def draw_point(self, gc, x, y):=0A=
"""=0A=
Draw a single point at x,y=0A=
"""
#~ print "draw_point"
dotnet.draw_point(gc, x, self.height - y)
=0A=
=0A=
def new_gc(self):=0A=
"""=0A=
Return an instance of a GraphicsContextDotNet=0A=
"""
return GraphicsContextDotNet()=0A=
=0A=
def points_to_pixels(self, points):=0A=
"""=0A=
Convert points to display units. Many imaging systems assume=0A=
some value for pixels per inch. Eg, suppose yours is 96 and=0A=
dpi =3D 300. Then points to pixels is: 96/72.0 * 300/72.0 * =
points=0A=
"""=0A=
#return 96/72.0 * 300/72.0 * points
# Speed up DpiX =3D DpiY =3D 96
#print "self.graphics.DpiX, DpiY =3D %d %d" % =
(self.graphics.DpiX, self.graphics.DpiY)
return points
#return 1.38889*points
#return points*(PIXELS_PER_INCH/72.0*self.graphics.DpiX/72.0)=0A=
class GraphicsContextBaseDotNet(GraphicsContextBase):=0A=
=0A=
# a mapping of dash styles
#~ _dashd_dotnet =3D {
#~ 'solid' : DashStyle.Solid,=0A=
#~ 'dashed' : DashStyle.Dash,=0A=
#~ 'dashdot' : DashStyle.DashDot,=0A=
#~ 'dotted' : DashStyle.Dot,
#~ 'dashdotdot' : DashStyle.DashDotDot
#~ }
=20
#~ _linejoin_dotnet =3D {
#~ 'miter' : LineJoin.Miter,=20
#~ 'round' : LineJoin.Round,=20
#~ 'bevel' : LineJoin.Bevel
#~ }
=20
# ToDo: What is a 'projecting' capstyle? Triangle? Arrow? Square
#~ _capstyle_dotnet =3D {
#~ 'butt' : LineCap.Flat,=20
#~ 'round' : LineCap.Round,=20
#~ 'projecting' : LineCap.Square
#~ } =20
=0A=
def __init__(self):=0A=
self._rgb =3D (0.0, 0.0, 0.0)=0A=
self._linewidth =3D 1.0=0A=
self._capstyle =3D 'butt'=0A=
self._joinstyle =3D 'miter'=0A=
self._dashes =3D None, None # if None it's converted to (-1, =
'') in tuple=0A=
self._cliprect =3D None # If None it's converted to (-1, -1, =
-1, -1) in tuple=0A=
self._linestyle =3D 'solid'=0A=
self._antialiased =3D 1 # use 0,1 not True, False for extension =
code=0A=
self._alpha =3D 1.0
self.colorConverter =3D ColorConverter()
=20
def gc_tuple(self):
dash_offset, dash_list =3D self._dashes
if not dash_offset:
dash_offset =3D -1
if not dash_list:
dash_list =3D ""
cliprect =3D self._cliprect
if not cliprect:
cliprect =3D (-1, -1, -1, -1)
return (self._rgb,=20
self._linewidth,=0A=
self._capstyle,=0A=
self._joinstyle,=0A=
(dash_offset, dash_list),=0A=
cliprect,=0A=
self._linestyle,=0A=
self._antialiased,=0A=
self._alpha)
=20
def get_color(self):
r,g,b =3D self._rgb
return Color.FromArgb(self._alpha *255, r*255, g*255, b*255)=0A=
=0A=
def get_antialiased(self):=0A=
"Return true if the object shuold try to do antialiased =
rendering"=0A=
return self._antialiased=0A=
=0A=
def get_clip_rectangle(self):=0A=
"""=0A=
Return the clip rectangle as (left, bottom, width, height)=0A=
"""=0A=
return self._cliprect=0A=
=0A=
def get_dashes(self):=0A=
"""=0A=
Return the dash information as an offset dashlist tuple The=0A=
dash list is a even size list that gives the ink on, ink off=0A=
in pixels. See p107 of to postscript BLUEBOOK for more info=0A=
=0A=
Default value is None=0A=
"""=0A=
return self._dashes=0A=
=0A=
def get_alpha(self):=0A=
"""=0A=
Return the alpha value used for blending - not supported on=0A=
all backends=0A=
"""=0A=
return self._alpha=0A=
=0A=
def get_capstyle(self):=0A=
"""=0A=
Return the capstyle as a string in ('butt', 'round', =
'projecting')=0A=
"""=0A=
return self._capstyle=0A=
=0A=
def get_joinstyle(self):=0A=
"""=0A=
Return the line join style as one of ('miter', 'round', 'bevel')=0A=
"""=0A=
return self._joinstyle=0A=
=0A=
# ToDo: BUG REPORT -> def get_linestyle(self, style):
def get_linestyle(self):=0A=
"""=0A=
Return the linestyle: one of ('solid', 'dashed', 'dashdot',=0A=
'dotted'). =0A=
"""=0A=
return self._linestyle=0A=
=0A=
def get_rgb(self):=0A=
"""=0A=
returns a tuple of three floats from 0-1. color can be a=0A=
matlab format string, a html hex color string, or a rgb tuple=0A=
"""=0A=
return self._rgb=0A=
=0A=
def set_antialiased(self, b):=0A=
"""=0A=
True if object should be drawn with antialiased rendering=0A=
"""=0A=
# use 0, 1 to make life easier on extension code trying to read =
the gc=0A=
if b:=20
self._antialiased =3D 1=0A=
else:=20
self._antialiased =3D 0=0A=
=0A=
def set_clip_rectangle(self, rectangle):=0A=
"""=0A=
Set the clip rectangle with sequence (left, bottom, width, =
height)=0A=
"""
self._cliprect =3D rectangle
# Do this with .NET? Need to add self.height and graphics =
object to class
#x, b, w, h =3D rectangle
#y =3D self.height - int(self.height + b)
#clipRegion =3D Rectangle(x, y, w, h) # upper-left_xy, width, =
height
#self.graphics.SetClip(clipRegion)
=0A=
=0A=
def set_alpha(self, alpha):=0A=
"""=0A=
Set the alpha value used for blending - not supported on=0A=
all backends=0A=
"""=0A=
self._alpha =3D alpha
=0A=
=0A=
def set_linestyle(self, style):=0A=
"""=0A=
Set the linestyle to be one of ('solid', 'dashed', 'dashdot',=0A=
'dotted'). =0A=
"""=0A=
if style not in ('solid', 'dashed', 'dashdot', =
'dotted','dashdotdot'):=0A=
error_msg('Unrecognized linestyle. Found %s' % js)=0A=
return=0A=
self._linestyle =3D style=0A=
=0A=
def set_dashes(self, dash_offset, dash_list):=0A=
"""=0A=
Set the dash style for the gc. dash offset is the offset=0A=
(usually 0). Dash list specifies the on-off sequence as=0A=
points=0A=
"""=0A=
self._dashes =3D dash_offset, dash_list=0A=
=0A=
def set_foreground(self, fg, isRGB=3DNone):=0A=
"""=0A=
Set the foreground color. fg can be a matlab format string, a=0A=
html hex color string, an rgb unit tuple, or a float between 0=0A=
and 1. In the latter case, grayscale is used.=0A=
=0A=
The GraphicsContext converts colors to rgb internally. If you=0A=
know the color is rgb already, you can set isRGB to True to=0A=
avoid the performace hit of the conversion=0A=
"""
pass=0A=
if isRGB:=0A=
self._rgb =3D fg
else:
self._rgb =3D self.colorConverter.to_rgb(fg)=0A=
=0A=
=0A=
def set_graylevel(self, frac):=0A=
"""=0A=
Set the foreground color to be a gray level with frac frac=0A=
"""=0A=
self._rgb =3D (frac, frac, frac)=0A=
=0A=
=0A=
def set_linewidth(self, w):=0A=
"""=0A=
Set the linewidth in points=0A=
"""=0A=
self._linewidth =3D w
=0A=
def set_capstyle(self, cs):=0A=
"""=0A=
Set the capstyle as a string in ('butt', 'round', 'projecting')=0A=
"""=0A=
if cs not in ('butt', 'round', 'projecting'):=0A=
error_msg('Unrecognized cap style. Found %s' % cs)=0A=
self._capstyle =3D cs
#~ self.pen.EndCap =3D self._capstyle_dotnet[cs]=0A=
=0A=
def set_joinstyle(self, js):=0A=
"""=0A=
Set the join style to be one of ('miter', 'round', 'bevel')=0A=
"""=0A=
if js not in ('miter', 'round', 'bevel'):=0A=
error_msg('Unrecognized join style. Found %s' % js)=0A=
self._joinstyle =3D js
#~ self.pen.LineJoin =3D self._linejoin_dotnet[js]=0A=
=0A=
def get_linewidth(self):=0A=
"""=0A=
Return the line width in points as a scalar=0A=
"""=0A=
return self._linewidth=0A=
=0A=
def copy_properties(self, gc):=0A=
'Copy properties from gc to self'=0A=
self._rgb =3D gc._rgb=0A=
self._linewidth =3D gc._linewidth=0A=
self._capstyle =3D gc._capstyle=0A=
self._joinstyle =3D gc._joinstyle=0A=
self._linestyle =3D gc._linestyle=0A=
self._dashes =3D gc._dashes=0A=
self._cliprect =3D gc._cliprect=0A=
self._antialiased =3D gc._antialiased=0A=
self._alpha =3D gc._alpha
=20
=0A=
class GraphicsContextDotNet(GraphicsContextBaseDotNet):=0A=
"""=0A=
The graphics context provides the color, line styles, etc... See=0A=
the gtk and postscript backends for examples of mapping the=0A=
graphics context attributes (cap styles, join styles, line widths,=0A=
colors) to a particular backend. In GTK this is done by wrapping=0A=
a gtk.gdk.GC object and forwarding the appropriate calls to it=0A=
using a dictionary mapping styles to gdk constants. In=0A=
Postscript, all the work is done by the renderer, mapping line=0A=
styles to postscript calls.=0A=
=0A=
The base GraphicsContext stores colors as a RGB tuple on the unit=0A=
interval, eg, (0.5, 0.0, 1.0). You will probably need to map this=0A=
to colors appropriate for your backend. Eg, see the ColorManager=0A=
class for the GTK backend. If it's more appropriate to do the=0A=
mapping at the renderer level (as in the postscript backend), you=0A=
don't need to override any of the GC methods. If it's more=0A=
approritate to wrap an instance (as in the GTK backend) and do the=0A=
mapping here, you'll need to override several of the setter=0A=
methods.=0A=
""" =20
pass
=20
=0A=
=0A=
########################################################################=0A=
# =0A=
# The following functions and classes are for matlab compatibility=0A=
# mode (matplotlib.matlab) and implement window/figure managers,=0A=
# etc...=0A=
#=0A=
########################################################################=0A=
=0A=
def draw_if_interactive():=0A=
"""=0A=
Update the figure after every command from the command line.=0A=
"""
pass
# Code below doesn't work... why?=0A=
#~ if matplotlib.is_interactive():=0A=
#~ figManager =3D Gcf.get_active()=0A=
#~ if figManager is not None:=0A=
#~ figManager.canvas.draw()
=0A=
def show():=0A=
"""=0A=
This is usually the last line of a matlab script and tells the=0A=
backend that it is time to draw. In interactive mode, this may be=0A=
a do nothing func. See the GTK backend for an example of how to=0A=
handle interactive versus batch mode=0A=
"""
for manager in Gcf.get_all_fig_managers():=0A=
manager.canvas.realize()=0A=
=0A=
=0A=
def new_figure_manager(num, *args, **kwargs):=0A=
"""=0A=
Create a new figure manager instance=0A=
"""=0A=
thisFig =3D Figure(*args, **kwargs)
l,b,w,h =3D thisFig.bbox.get_bounds()=0A=
w =3D int(math.ceil(w))=0A=
h =3D int(math.ceil(h))=0A=
canvas =3D FigureCanvasDotNet(w, h)
canvas.figure =3D thisFig
canvas.figurenum =3D num
manager =3D FigureManagerDotNet(canvas, num)=0A=
return manager
=20
=0A=
class FigureCanvasDotNet(FigureCanvasBase):=0A=
"""=0A=
The canvas the figure renders into. Calls the draw and print fig=0A=
methods, creates the renderers, etc...=0A=
=0A=
Public attribute=0A=
=0A=
figure - A Figure instance=0A=
"""
=20
def __init__(self, w, h):
self.figure =3D None
self.figurenum =3D None
self.width =3D w #640 =20
self.height =3D h #480
self._isRealized =3D False
self._isConfigured =3D False
self.renderer =3D RendererDotNet(self.width, self.height)
#~ self.Closed +=3D self.on_close # Release objects
=0A=
def draw(self):=0A=
"""=0A=
Draw the figure using the renderer=0A=
"""
need_new_renderer =3D False
try:
self.renderer
except:
need_new_renderer =3D True
=20
if need_new_renderer:
if self.figure !=3D None:
l,b,w,h =3D self.figure.bbox.get_bounds()=0A=
w =3D int(math.ceil(w))=0A=
h =3D int(math.ceil(h))
self.height =3D h
self.width =3D w =0A=
self.renderer =3D RendererDotNet(self.width, self.height)
#print "New RendererDotNet"=0A=
self.figure.draw(self.renderer)
self.renderer.show()
=20
#~ def on_close(self, sender, args):
#~ #WinForms.MessageBox.Show("Info", "Closing form..")
#~ Gcf.destroy(self.figurenum) =0A=
=0A=
def print_figure(self, filename, dpi=3D150,=0A=
facecolor=3D'w', edgecolor=3D'w',=0A=
orientation=3D'portrait'):=0A=
=0A=
"""=0A=
Render the figure to hardcopy. Set the figure patch face and=0A=
edge colors. This is useful because some of the GUIs have a=0A=
gray figure face color background and you'll probably want to=0A=
override this on hardcopy=0A=
"""=0A=
# set the new parameters=0A=
origDPI =3D self.figure.dpi.get()=0A=
origfacecolor =3D self.figure.get_facecolor()=0A=
origedgecolor =3D self.figure.get_edgecolor()=0A=
self.figure.dpi.set(dpi)=0A=
self.figure.set_facecolor(facecolor)=0A=
self.figure.set_edgecolor(edgecolor) =0A=
=0A=
renderer =3D RendererDotNet(self.width, self.height)=0A=
self.figure.draw(renderer)=0A=
# do something to save to hardcopy=0A=
=0A=
# restore the new params and redraw the screen if necessary=0A=
self.figure.dpi.set(origDPI)=0A=
self.figure.set_facecolor(origfacecolor)=0A=
self.figure.set_edgecolor(origedgecolor)=0A=
self.draw()=0A=
=0A=
def realize(self, *args):=0A=
"""=0A=
This method will be called when the system is ready to draw,=0A=
eg when a GUI window is realized=0A=
"""=0A=
self._isRealized =3D True =0A=
self.draw()
=0A=
class FigureManagerDotNet(FigureManagerBase):=0A=
"""=0A=
Public attributes=0A=
=0A=
canvas : The FigureCanvas instance=0A=
num : The Figure number=0A=
toolbar : The gtk.Toolbar=0A=
window : The gtk.Window=0A=
=0A=
"""
pass=0A=
#~ def __init__(self, canvas, num):=0A=
#~ FigureManagerBase.__init__(self, canvas, num)=0A=
=0A=
#~ dotnet.window_title("Figure %d" % num)=0A=
#~ self.canvas.show()=0A=
=0A=
=0A=
########################################################################=0A=
# =0A=
# Now just provide the standard names that backend.__init__ is expecting=0A=
# =0A=
########################################################################=0A=
=0A=
=0A=
FigureManager =3D FigureManagerDotNet=0A=
error_msg =3D error_msg_dotnet=0A=
=0A=
|
|
From: Andrew S. <str...@as...> - 2004-11-05 04:55:41
|
Thane wrote: > Attached are the files needed for running a .NET backend. This code > still needs a lot of work, but this should demonstrate the feasibility > of a .NET backend, for those interested. > Dear Thane, This looks very interesting, but what about the source to _backend_dotnet.pyd? Did you forget to include that? |
|
From: Thane <th...@ma...> - 2004-11-05 16:16:58
|
My source code posting seems to have bounced. I got the following message: host mail.sourceforge.net [66.35.250.206]: 550-"For the time being, we are blocking all mail with the .zip extension.... What's the best way to distribute a project? > -----Original Message----- > From: mat...@li... [mailto:matplotlib- > dev...@li...] On Behalf Of Andrew Straw > Sent: Thursday, November 04, 2004 9:57 PM > To: th...@ma...; mat...@li... > Subject: Re: [matplotlib-devel] .NET backend > > Thane wrote: > > > Attached are the files needed for running a .NET backend. This code > > still needs a lot of work, but this should demonstrate the feasibility > > of a .NET backend, for those interested. > > > Dear Thane, > > This looks very interesting, but what about the source to > _backend_dotnet.pyd? Did you forget to include that? > > > > ------------------------------------------------------- > This SF.Net email is sponsored by: > Sybase ASE Linux Express Edition - download now for FREE > LinuxWorld Reader's Choice Award Winner for best database on Linux. > http://ads.osdn.com/?ad_id=5588&alloc_id=12065&op=click > _______________________________________________ > Matplotlib-devel mailing list > Mat...@li... > https://lists.sourceforge.net/lists/listinfo/matplotlib-devel > |
|
From: John H. <jdh...@ac...> - 2004-11-05 16:39:24
|
>>>>> "Thane" == Thane <th...@ma...> writes:
Thane> My source code posting seems to have bounced. I got the
Thane> following message: host mail.sourceforge.net
Thane> [66.35.250.206]: 550-"For the time being, we are blocking
Thane> all mail with the .zip extension....
If you email it to me, I'll post it on the matplotlib web site, and
follow-up here with a link to it. Best if you include all the code
(*.py and *.c) in one zip along with the pyd and any examples since
the sf archives won't include your previous plain text)attachments,
and it will be easiest for people searching the archives to get
everything in one bundle.
Can you clarify something for me? In the backend comments you wrote
0.2.0 11/01/04 Created a DLL for the backend. Should work with any .NET machine.
It's still the case, isn't it, that matplotlib itself will not work on
a general .Net machine? In particular, it won't work on IronPython
because it uses numerix extension code as well as it's own, right?
How does PythonNet handle this problem, and is it fair to say that
matplotlib with your backend currently work only on PythonNet?
Thanks!
JDH
|
|
From: Thane <th...@ma...> - 2004-11-05 17:56:34
|
Thanks John, I'll be forwarding the source separately. Now to your
questions:
1. [JDH] It's still the case, isn't it, that matplotlib itself will not
work on a general .Net machine?
[TKP] No. Matplotlib DOES work on a general .Net machine. I've run
successful -- but not exhaustive -- tests of the "DotNet" backend on
("normal") CPython 2.3, and PythonNet.
2. [JDH] In particular, it won't work on IronPython because it uses numerix
extension code as well as it's own, right?
[TKP] Yes and no. Matplotlib doesn't work on IronPython (yet) as the
supporting libraries are not yet there. (With some effort, this might be
feasible with PyPy.) However, the "DotNet" backend (DLL) works just fine.
Output from the session below creates a graphic window and draws a blue line
on it. This isn't too useful except to note that once the libraries are in
place, matplotlib will indeed work on IronPython.
C:\Python\IronPython-0.6\bin>IronPythonConsole
>>> import sys
>>> sys.LoadAssemblyFromFile("./_backend_dotnet.pyd")
>>> foo = backend_dotnet.GraphicsForm(640, 480)
IronPython.Objects.PythonNameError: name 'backend_dotnet' is not defined
at IronPython.Objects.Frame.GetGlobal(String name)
at input_2.Run(Frame frame)
at IronPythonConsole.IronPython.DoInteractive()
>>> import backend_dotnet
>>> foo = backend_dotnet.GraphicsForm(640, 480)
>>> from System.Drawing import *
>>> bar = Color.Blue
>>> bar
Color [Blue]
>>> pen = Pen(bar)
>>> pen
<System.Drawing.Pen object at 0x00000021>
>>> foo.draw_line(pen, 0, 0, 100, 100)
>>> foo.Repaint()
>>>
3. [JDH] How does PythonNet handle this problem, and is it fair to say that
matplotlib with your backend currently work only on PythonNet?
[TKP] That was the case, but isn't any longer. A bit of history... I
originally wrote the backend in PythonNet, and consequently it would only
work with the PythonNet distribution. However, (foolishly) encouraged by my
success, I wrote a DLL so that this backend could work with any .Net
machine. I say foolishly, because the DLL took about 5 times as long to
write as the Python version! It now works also with the "regular" Python
(aka CPython) distribution.
> -----Original Message-----
> From: John Hunter [mailto:jdh...@ac...]
> Sent: Friday, November 05, 2004 9:30 AM
> To: th...@ma...
> Cc: 'Andrew Straw'; mat...@li...
> Subject: Re: [matplotlib-devel] .NET backend
>
> >>>>> "Thane" == Thane <th...@ma...> writes:
>
> Thane> My source code posting seems to have bounced. I got the
> Thane> following message: host mail.sourceforge.net
> Thane> [66.35.250.206]: 550-"For the time being, we are blocking
> Thane> all mail with the .zip extension....
>
> If you email it to me, I'll post it on the matplotlib web site, and
> follow-up here with a link to it. Best if you include all the code
> (*.py and *.c) in one zip along with the pyd and any examples since
> the sf archives won't include your previous plain text)attachments,
> and it will be easiest for people searching the archives to get
> everything in one bundle.
>
> Can you clarify something for me? In the backend comments you wrote
>
> 0.2.0 11/01/04 Created a DLL for the backend. Should work with any
> .NET machine.
>
> It's still the case, isn't it, that matplotlib itself will not work on
> a general .Net machine? In particular, it won't work on IronPython
> because it uses numerix extension code as well as it's own, right?
> How does PythonNet handle this problem, and is it fair to say that
> matplotlib with your backend currently work only on PythonNet?
>
> Thanks!
> JDH
>
>
>
|
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X