""" """ from plot_utility import * from wxPython import wx from colormap import colormap_map #-----------------------------------------------------------------------# #------- Attribute list/functions for objects in wxPython --------------# #-----------------------------------------------------------------------# # Actually the wxWindows color dialog is used to set most # color properties, so this can be ignored. The list of supported # name colors is much longer than this colors = ['black','blue','green','red','yellow','cyan','brown','orange', 'purple','grey','white','light grey'] line_widths = [1,2,3,4,5] tick_length = [0,1,2,3,4,5,6,7,8,9,10] line_style_map = {'solid':wx.wxSOLID,'dot dash': wx.wxDOT_DASH, 'dash':wx.wxSHORT_DASH,'dot': wx.wxDOT, 'long dash':wx.wxLONG_DASH,'transparent':wx.wxTRANSPARENT} line_styles = line_style_map.keys() fill_style_map = {'solid':wx.wxSOLID,'stipple': wx.wxSTIPPLE, 'back hatch':wx.wxBDIAGONAL_HATCH, 'diag hatch': wx.wxCROSSDIAG_HATCH, 'forward hatch':wx.wxFDIAGONAL_HATCH, 'cross hatch': wx.wxCROSS_HATCH, 'horz hatch': wx.wxHORIZONTAL_HATCH, 'vert hatch': wx.wxVERTICAL_HATCH, 'transparent':wx.wxTRANSPARENT } fill_styles = fill_style_map.keys() image_type_map = { 'jpg': wx.wxBITMAP_TYPE_JPEG, 'jpeg': wx.wxBITMAP_TYPE_JPEG, 'png': wx.wxBITMAP_TYPE_PNG, 'pcx': wx.wxBITMAP_TYPE_PCX, 'tif': wx.wxBITMAP_TYPE_TIF, 'tiff': wx.wxBITMAP_TYPE_TIF, } def get_color(in_color): """ Convert a color name or rgb sequence to a wxColour """ if type(in_color) == type(''): color = wx.wxNamedColour(in_color) else: r,g,b = in_color ##color = wx.wxColour(r,g,b) # mod by GAP 26092003 color = wx.wxColour(int(r),int(g),int(b)) return color def default_font(): """ The default font for text objects. This is a method instead of a global variable so that each text object will get its own font object that can change indepedently of all others. """ return wx.wxFont(12, wx.wxSWISS, wx.wxNORMAL, wx.wxNORMAL,wx.false,"Arial") #-----------------------------------------------------------------------# #------------------------- Drawing utilities ---------------------------# #-----------------------------------------------------------------------# def draw_point_list(start,stop,pen,dc): """ Draw lines between the points listed in start and stop. start and stop are 2xN arrays of x,y point coordinates. N lines are drawn, one between each of the start,stop pairs using the specified pen. The lines are drawn on the given device context, dc. """ dc.SetPen(pen) for i in range(len(start)): pt1 = start[i] pt2 = stop[i] dc.DrawLine(pt1[0],pt1[1],pt2[0],pt2[1]) dc.SetPen(wx.wxNullPen) #-----------------------------------------------------------------------# #-------------------------- text objects -------------------------------# #-----------------------------------------------------------------------# class text_object(box_object,property_object): """ Text objects can be placed anywhere in the plot window. They have "font", "color", and "rotate" attributes as well as "visible" attribute that specifies whether the text is displayed. The font attribute is a wxWindows font. "color" can either be a named color (string such as 'black') or a 3-element sequence specifiy rgb values (0 to 255). Rotatation is specified in degrees. Currently only 0 and 90 degree rotation are supported. Issues: -- The font attribute seems to be ignored when drawing rotated text. (wxPython) -- Need to think about origin when drawing rotated text. The current approach assumes the box_object does not rotate as the text rotates, so the insertion point changes from the topleft to bottomleft corner. This inconsistency may be problematic in the future, but it was convienient for laying out axis titles. -- There is some ugliness with calculating the size of the object because text needs to know the dc it is drawing in to know its size. As a result, you must call set_dc(dc) before calling size. To keep from having a dc reference hanging around, I added a clear_dc() method. Necessary?? """ _attributes = {'color': ['black',colors,"Color of line"], 'font': [None,[],"Font of text object"], 'rotate': [0,[], "Angular rotation of text in degrees"], 'visible': ['yes',[], "'yes' or 'no'. Is text visible"], } #think about rotation and topleft def __init__(self,text=None,topleft=None,**attr): property_object.__init__(self,attr) box_object.__init__(self, (0,0), (0,0)) if text is None: self.text = '' else: self.text = text if not topleft: self.topleft = array((0,0),TYPE) else: self.topleft = array(topleft,TYPE) self.translate((0,0)) # make sure each object has its own font object. if not self.font: self.font = default_font() if not self.color: self.color = 'black' # ugly hack to get size calculations to work def set_dc(self,dc): """ Set the device context of the text_object for size calculations. """ self.dc = dc def clear_dc(self): """ Get rid of the device context. """ #try/except cludge added right before SPIE conference #find error and fix. try: del self.dc except: pass def size(self): """ Calculate the width and length of the text in pixels. If "visible" == 'no', size() always returns (0,0) regardless of the text size. If the rotation angle is 90 degrees, the width of the text is actually its height on the screen and visa-versa. Issues: -- haven't really thought about how to handle non-orthogonal text rotations. """ if self.visible in ['yes','on',1] and self.text: if not hasattr(self,'dc'): raise ValueError, "no device context to calculate text " \ "size. Call set_dc() first." preset = (self.dc.GetFont() == self.font) if not preset: self.dc.SetFont(self.font) sz= array(self.dc.GetTextExtent(self.text)) # Commented the following line out since calling this # seems to turn of plotting of any text #if not preset: self.dc.SetFont(wx.wxNullFont) # should do something here to calculate real width # this only works for 90 degree rotations if self.rotate: sz = sz[::-1] else: sz = array((0,0)) return sz def set_size(self): raise ValueError, "Can't set size of text objects" def draw(self,dc): """ Draw the text on the screen. If the text is rotated by 90 degrees, the "insertion point" is the bottom-left corner. Otherwise the stanard top-left corner is used. """ if self.visible in ['yes','on',1] and self.text: self.set_dc(dc) color = get_color(self.color) dc.SetTextForeground(color) dc.SetFont(self.font) # hmmm. rotated text isn't being drawn with the correct font # also need to think about origin for rotated text if self.rotate == 90: ##dc.DrawRotatedText(self.text,self.left(),self.bottom(), ## self.rotate) # mod by GAP 26092003 dc.DrawRotatedText(self.text,int(self.left()),int(self.bottom()), int(self.rotate)) else: dc.DrawText(self.text,self.left(),self.top()) dc.SetPen(wx.wxNullPen) dc.SetFont(wx.wxNullFont) # hmmm. really should clear the dc... self.clear_dc() class text_window(wx.wxWindow,text_object): """ Window is currently size=0,0 window for event handling. Text is NOT drawn in the window. Maybe will do this later, but not sure if it is worth handling drawing th background (does GTK support transparent windows?). """ def __init__(self,parent,text=None,topleft=None,**attr): self.plot_canvas = parent wx.wxWindow.__init__(self,parent,-1) #not quite right with attr - 1.6 makes this cleaner text_object.__init__(self,text,topleft) self.SetSize((0,0)) def format_popup(self,pos): menu = wx.wxMenu() menu.Append(500, 'Change Text', 'Change Text') wx.EVT_MENU(self, 500, self.OnText) menu.Append(600, 'Change Font', 'Change Text Font') wx.EVT_MENU(self, 600, self.OnFont) #print 'fp:',self.text menu.UpdateUI() self.PopupMenuXY(menu,pos[0],pos[1]) def OnFont(self,event): data = wx.wxFontData() data.SetColour(get_color(self.color)) data.SetInitialFont(self.font) dlg = wx.wxFontDialog(self, data) if dlg.ShowModal() == wx.wxID_OK: data = dlg.GetFontData() self.font = data.GetChosenFont() color = data.GetColour() self.color = color.Red(),color.Green(),color.Blue() self.plot_canvas.update() dlg.Destroy() def OnText(self,event): #print 'on text:',self.text dlg = wx.wxTextEntryDialog(self.GetParent(), 'New Text', defaultValue=self.text) if dlg.ShowModal() == wx.wxID_OK: self.text = dlg.GetValue() self.plot_canvas.update() dlg.Destroy() #-----------------------------------------------------------------------# #-------------------------- legend_object ------------------------------# #-----------------------------------------------------------------------# class legend_object(property_object,box_object): """ Draws a legend to the lines plotted on the graph. Unimplemented. """ _attributes = { 'position': ['auto',[],"Specify location for legend - auto only for now"], 'font': [None,[],"Font of tick labels"], 'border': ['yes',['yes','no'],"Place border around legend"], 'fill_color': ['white',colors,"Background color in legend"], 'line_length':[30,[],"Length of lines displayed in legend"], 'visible': ['yes',['yes','on','no','off'],"Show the legend"], } def __init__(self, **attr): property_object.__init__(self,attr) box_object.__init__(self,(0,0),(0,0)) def layout(self,graph_lines,graph_area,dc): self.graph_lines = graph_lines # keep a pointer so we can clone # properties when drawing # create duplicates of the lines #figure out where to put it #create legend def draw(self,dc): if self.visible in ['yes','on']: # beginning of junk that should be moved # in to a line object self.labels = [] self.lines = [] self.markers = [] for line in self.graph_lines: #self.labels.append(text_object(line.name)) self.labels.append(text_object('bug')) self.labels[-1].set_dc(dc) #create legend lines and markers and steal properties #from actual line. We'll update the points later # figure out size w,h = 0,0 margin = 0 line_pts = [] line_right = point_object((self.line_length+5,0)) previous = box_object((0,0),(0,0)) #a 0x0 box at the origin for i in range(len(self.labels)): label = self.labels[i] label.below(previous,margin) label.right_of(line_right) new_line = poly_line([(0,label.center_y()), (self.line_length,label.center_y())]) new_line.clone_properties(line.line) self.lines.append(new_line) new_marker = poly_marker([(self.line_length/2., label.center_y())]) new_marker.clone_properties(line.markers) self.markers.append(new_marker) previous = label for items in self.labels: items.clear_dc() # end of junk that should be moved for item in self.lines: item.draw(dc) for item in self.markers: item.draw(dc) for item in self.labels: item.draw(dc) #-----------------------------------------------------------------------# #---------------------------- axis_object ------------------------------# #-----------------------------------------------------------------------# class axis_object(property_object): """ Class for drawing an axis on a graph. """ _attributes = { 'labels_visible': ['yes',['yes','no'], "Turns on/off labels for axis"], 'label_color': ['black',colors, "Color of tick labels"], 'label_font': [None,[],"Font of tick labels"], 'label_location': ['minus',['plus','minus'],"Side of axis for labels"], 'label_offset': [4,[],"Offset in pixels from tick marks to tick labels"], 'ticks_visible': ['yes',['yes','no'], "Turns on/off tick marks for axis"], 'tick_in': [5,tick_length, "Tick length in pixels into the graph"], 'tick_out': [0,tick_length, "Tick length in pixels out ofthe graph"], 'tick_weight':[1,line_widths, "Width of tick lines"], 'tick_color': ['black',colors,"Color of tick labels"], 'tick_style': ['solid',line_styles,"Tick mark and axis line style"], 'tick_interval': ['auto',[],"Tick interval: 'auto', 'linear','log', " \ "or value"], 'bounds': [['auto','auto'],[],"Axis boundary: 'auto', 'fit', or value"], 'grid_visible': ['yes',['yes','no'], "Turns on and off grid lines" \ " for axis"], 'grid_color': ['light grey',colors,"Color for grid lines"], 'grid_weight':[1,line_widths, "Width of grid lines"], 'grid_style': ['dot',line_styles,"Line style for grid lines"], } # axis crossing # others... def __init__(self, rotate = 0, graph_location='above',**attr): # attr to allow or disallow labels property_object.__init__(self,attr) self.rotate = rotate if graph_location == 'above' or graph_location == 'left': self.tick_sign = -1 elif graph_location == 'below' or graph_location == 'right': self.tick_sign = 1 else: raise ValueError, "graph_location can be 'left','right','above" \ ", or 'below'. You tried '%s'" % graph_location if not self.label_font: self.label_font = default_font() self.label_font.SetPointSize(10) self.bounds = ['auto', 'auto'] # each object needs its own bounds list self.omit_first_label = 0 self.omit_last_label = 0 def calculate_ticks(self,data_bounds): """ data bounds is (lower bound, upper bound) axis_settings is a 3-tuple (lower bound, upper bound, interval) Each of its settings can be 'auto', or a numerical value. In addition, the bounds can be 'fit' and interval can be 'linear' or 'log' (well, not yet). 'auto' -- bound or interval is calculated for you based on the data bounds. 'fit' -- bound is set to be slightly beyond than data_bounds value -- bound is exactly to specified value. Typical settings are the following: ['auto','auto','auto' """ bounds_settings = [self.bounds[0], self.bounds[1], self.tick_interval] self.ticks = auto_ticks(data_bounds,bounds_settings) # This code tries to omit printing of first and last labels when they # are strange values due to 'fit' settings. self.omit_first_label = 0 self.omit_last_label = 0 if len(self.ticks) > 3: delta = self.ticks[2] - self.ticks[1] first_delta = self.ticks[1] - self.ticks[0] last_delta = self.ticks[-1] - self.ticks[-2] first_diff = abs(first_delta - delta) last_diff = abs(last_delta - delta) if first_diff > .01*delta: self.omit_first_label = 1 if last_diff > .01*delta: self.omit_last_label = 1 self.create_labels() def create_labels(self): self.labels = [] tick_text = format_tick_labels(self.ticks) for text in tick_text: label = text_object(text,(0,0),font=self.label_font, color=self.label_color) self.labels.append(label) if len(self.labels): if self.omit_first_label: self.labels[0] = text_object(' ',(0,0),font=self.label_font, color=self.label_color) if self.omit_last_label: self.labels[-1] = text_object(' ',(0,0),font=self.label_font, color=self.label_color) def max_label_size(self,dc,idx): dim = [0] for i in self.labels: i.set_dc(dc) dim.append(i.size()[idx]) i.clear_dc() return max(dim) + self.tick_out + self.label_offset def max_label_width(self,dc): return self.max_label_size(dc,0) def max_label_height(self,dc): return self.max_label_size(dc,1) def range(self): return float(self.ticks[-1]-self.ticks[0]) def layout(self,graph_area,dc): if self.rotate == 0: length = graph_area.width() grid_length = graph_area.height() elif self.rotate == 90 or self.rotate == -90: length = graph_area.height() grid_length = graph_area.width() else: raise ValueError,'rotate must be 0 or 90. It is %d' % self.rotate # translate to screen units for the ticks. scale = length / float(self.ticks[-1] - self.ticks[0]) tick_locations = floor((self.ticks - self.ticks[0]) * scale) # make array of points with tick screen units as x value, 0 for y value tick_points = [] for i in tick_locations: tick_points.append((i,0)) tick_points = array(tick_points) # create array of end points for the tick lines tick_start = tick_points + array((0,self.tick_in*self.tick_sign)) tick_stop = tick_points - array((0,self.tick_out*self.tick_sign)) # set up grid lines grid_start = tick_points grid_stop = tick_points + array((0,grid_length*self.tick_sign)) # rotate all of this stuff to the correct axis orientation. angle = -self.rotate*pi/180 # neg. since up is y decreasing in canvas. zero_point = array((0,0)) self.tick_points = rotate(tick_points,zero_point,angle) self.tick_start = rotate(tick_start,zero_point,angle) self.tick_stop = rotate(tick_stop,zero_point,angle) self.grid_start = rotate(grid_start,zero_point,angle) self.grid_stop = rotate(grid_stop,zero_point,angle) #offset the labels from the tick_points if self.label_location == 'plus': if tan(self.rotate*pi/180) < 1: label_angle = angle - pi/2 else: label_angle = angle + pi/2 elif self.label_location == 'minus': if tan(self.rotate*pi/180) < 1: label_angle = angle + pi/2 else: label_angle = angle - pi/2 for i in range(len(self.labels)): self.labels[i].set_dc(dc) pt = point_object(self.tick_points[i]) self.labels[i].radial_offset_from(pt,label_angle, margin=self.label_offset) self.labels[i].clear_dc() self.labels[i].set_dc(dc) # for fast line drawing. # not currently used self.single_grid_line = [] self.single_tick_line = [] ts = map(tuple,self.tick_start) tc = map(tuple,self.tick_points) te = map(tuple,self.tick_stop) N = len(self.tick_start) for i in range(N): self.single_tick_line.append(tc[i]) self.single_tick_line.append(te[i]) self.single_tick_line.append(ts[i]) self.single_tick_line.append(tc[i]) def move(self,offset): self.tick_start = self.tick_start + offset self.tick_stop = self.tick_stop + offset self.tick_points = self.tick_points + offset self.grid_start = self.grid_start + offset self.grid_stop = self.grid_stop + offset # need to rebuild fast_line drawing stuff for i in self.labels: i.translate(offset) def contains(self,pt,dc): mins,maxs = [],[] for i in self.labels: i.set_dc(dc) lo,hi = bounding_points(self.labels) for i in self.labels: i.clear_dc() mins.append(lo) mins.append(minimum.reduce(self.tick_start)) mins.append(minimum.reduce(self.tick_stop)) mins.append(minimum.reduce(self.tick_points)) maxs.append(hi) maxs.append(maximum.reduce(self.tick_start)) maxs.append(maximum.reduce(self.tick_stop)) maxs.append(maximum.reduce(self.tick_points)) lo = minimum.reduce(mins) hi = maximum.reduce(maxs) sz = hi-lo return box_object(lo,sz).contains(pt) def draw_ticks(self,dc): if self.ticks_visible in ['yes','on']: style = line_style_map[self.tick_style] color = get_color(self.tick_color) pen = wx.wxPen(color, self.tick_weight, style) draw_point_list(self.tick_start,self.tick_stop,pen,dc) #dc.DrawLines(self.single_tick_line) # draw axis line here also pt1 = self.tick_points[0] pt2 = self.tick_points[-1] draw_point_list([pt1],[pt2],pen,dc) def draw_grid_lines(self,dc): if self.grid_visible in ['yes','on']: style = line_style_map[self.grid_style] color = get_color(self.grid_color) pen = wx.wxPen(color,self.grid_weight, style) draw_point_list(self.grid_start,self.grid_stop,pen,dc) def draw_labels(self,dc): if self.labels_visible in ['yes','on']: for label in self.labels: label.draw(dc) def draw_lines(self,dc): self.draw_grid_lines(dc) self.draw_ticks(dc) def draw(self,dc): self.draw_labels(dc) # really only need to do this sometimes... self.draw_lines(dc) class axis_window(wx.wxWindow,axis_object): """ Window is currently size=0,0 window for event handling. Text is NOT drawn in the window. Maybe will do this later, but not sure if it is worth handling drawing th background (does GTK support transparent windows?). """ def __init__(self,parent, rotate = 0, graph_location='above',**attr): self.plot_canvas = parent wx.wxWindow.__init__(self,parent,-1) #not quite right with attr - 1.6 makes this cleaner axis_object.__init__(self,rotate,graph_location) self.SetSize((0,0)) def format_popup(self,pos): menu = wx.wxMenu() menu.Append(600, 'Change Font', 'Change Text Font') wx.EVT_MENU(self, 600, self.OnFont) menu.UpdateUI() self.PopupMenuXY(menu,pos[0],pos[1]) def OnFont(self,event): data = wx.wxFontData() data.SetColour(get_color(self.label_color)) data.SetInitialFont(self.label_font) dlg = wx.wxFontDialog(self, data) if dlg.ShowModal() == wx.wxID_OK: data = dlg.GetFontData() self.label_font = data.GetChosenFont() color = data.GetColour() self.label_color = color.Red(),color.Green(),color.Blue() self.plot_canvas.update() dlg.Destroy() #-----------------------------------------------------------------------# #-------------------------- border_object ------------------------------# #-----------------------------------------------------------------------# class border_object(property_object): _attributes = { 'ticks_visible': ['yes',['yes','no'], "Turns on/off tick marks for axis"], 'tick_in': [5,tick_length, "Tick length in pixels into the graph"], 'tick_out': [0,tick_length, "Tick length in pixels out ofthe graph"], 'tick_weight':[1,line_widths, "Width of tick lines"], 'tick_color': ['black',colors,"Color of tick labels"], 'tick_style': ['solid',line_styles,"Tick mark line style"], 'visible': ['yes',['yes','no'], "Turns on and off border marks for axis"], 'color': ['black',colors,"Color for border lines"], 'weight':[1,line_widths, "Width of border lines"], 'style': ['solid',line_styles,"Line style for border lines"], } def __init__(self,**attr): # attr to allow or disallow labels property_object.__init__(self,attr) def add_ticks(self,tick_points, origin, tick_in, tick_out): offset = array((0,self.tick_out)) self.tick_start.append( tick_points + offset + origin ) offset = array((0,self.tick_in)) self.tick_stop.append( tick_points + offset + origin ) def layout(self,graph_area,x_axis,y_axis): # top x_points = x_axis.tick_points - x_axis.tick_points[0] y_points = y_axis.tick_points - y_axis.tick_points[0] #clear tick lines self.tick_start = [] self.tick_stop = [] self.tick_center = [] #top origin = array((graph_area.left(),graph_area.top())) offset = array((0,-self.tick_out)) self.tick_start.append( x_points + offset + origin ) offset = array((0,self.tick_in)) self.tick_stop.append( x_points + offset + origin ) self.tick_center.append(x_points + origin) #right origin = array((graph_area.right(),graph_area.bottom())) offset = array((self.tick_out,0)) self.tick_start.append( y_points + offset + origin ) offset = array((-self.tick_in,0)) self.tick_stop.append( y_points + offset + origin ) self.tick_center.append(y_points + origin) #bottom origin = array((graph_area.left(),graph_area.bottom())) offset = array((0,self.tick_out)) self.tick_start.append( x_points + offset + origin ) offset = array((0,-self.tick_in)) self.tick_stop.append( x_points + offset + origin ) self.tick_center.append(x_points + origin) #left origin = array((graph_area.left(),graph_area.bottom())) offset = array((-self.tick_out,0)) self.tick_start.append( y_points + offset + origin ) offset = array((self.tick_in,0)) self.tick_stop.append( y_points + offset + origin ) self.tick_center.append(y_points + origin) self.tick_start = concatenate(self.tick_start) self.tick_stop = concatenate(self.tick_stop) self.tick_center = concatenate(self.tick_center) self.border_start = [] self.border_stop = [] gr = graph_area # could do a rect instead, but it always seems # off by 1 or so. Do this for now. self.border_start.append((gr.left(),gr.top())) self.border_stop.append((gr.left(),gr.bottom())) self.border_start.append((gr.left(),gr.top())) self.border_stop.append((gr.right(),gr.top())) self.border_start.append((gr.left(),gr.bottom())) self.border_stop.append((gr.right(),gr.bottom())) self.border_start.append((gr.right(),gr.top())) self.border_stop.append((gr.right(),gr.bottom())) self.border_start = array(self.border_start) self.border_stop = array(self.border_stop) # this stuff is only needed for the fast_draw method # needs slight amount of work self.single_line = [] ts = map(tuple,self.tick_start) tc = map(tuple,self.tick_center) te = map(tuple,self.tick_stop) N = len(self.tick_start) for i in range(N): self.single_line.append(tc[i]) self.single_line.append(te[i]) self.single_line.append(ts[i]) self.single_line.append(tc[i]) def draw(self,dc): vis = self.visible in ['yes','on'] tick_vis = self.ticks_visible in ['yes','on'] #if vis and tick_vis: if 0: # Really should check styles etc. here to make # sure the are the same. self.draw_fast(dc) else: #draw border if vis: style = line_style_map[self.style] color = get_color(self.color) pen = wx.wxPen(color, self.weight, style) draw_point_list(self.border_start,self.border_stop,pen,dc) #draw ticks if tick_vis: style = line_style_map[self.tick_style] color = get_color(self.tick_color) pen = wx.wxPen(color, self.tick_weight, style) draw_point_list(self.tick_start,self.tick_stop,pen,dc) def draw_fast(self,dc): """ This approach uses wxPythons DrawLines to draw the entire border in one call instead of drawing each tick individually. It is 5-10 times faster, but draws the border and ticks all in the same style. (not a big draw back...) """ style = line_style_map[self.style] color = get_color(self.color) pen = wx.wxPen(color, self.weight, style) dc.SetPen(pen) dc.DrawLines(self.single_line) dc.SetPen(wx.wxNullPen) class poly_points(property_object): def __init__(self, points, attr=None): property_object.__init__(self,attr) self.points = array(points) self.scaled = array(self.points,copy=True) #self.scaled = map(tuple,self.points) def bounding_box(self): return minimum.reduce(self.points), \ maximum.reduce(self.points) def scale_and_shift(self, scale=1, shift=0): self.scaled = scale*self.points+shift #self.scaled = map(tuple,self.scaled) class poly_line(poly_points): _attributes = {'color': ['black',colors,"Color of line"], 'weight': [1,line_widths, "Weight of Line"], 'visible': ['yes',['yes','no'], "Turn on/off line"], 'style': ['solid',line_styles,"solid, dash, dot dash, or dot"] } def __init__(self, points, **attr): poly_points.__init__(self, points, attr) def draw(self, dc): if self.visible in ['on','yes']: color = get_color(self.color) style = line_style_map[self.style] dc.SetPen(wx.wxPen(color, self.weight,style)) try: dc.DrawLines(self.scaled) except: dc.DrawLines(map(tuple,self.scaled)) dc.SetPen(wx.wxNullPen) marker_styles = ['circle','square','dot','triangle','down_triangle',\ 'cross','plus'] class poly_marker(poly_points): """ adding a layout method that did most of the computation and marker function selection upfront might speed up drawing """ _attributes = { 'outline_color': ['black',colors,"Color of marker outline"], 'outline_weight': [1,line_widths, "Weight of Line"], 'fill_color': ['black',colors,"Fill color of marker"], 'fill_style': ['solid',fill_styles, "pattern used when filling marker"], 'size': [1,[],"Size of marker"], 'symbol': ['circle',marker_styles,"Shape used for marker"], 'visible': ['yes',['yes','no'], "Turn on/off markers"], } def __init__(self,points,**attr): poly_points.__init__(self,points,attr) def draw(self,dc): if self.visible in ['on','yes']: color = get_color(self.outline_color) weight = self.outline_weight size = self.size fill_color = get_color(self.fill_color) fill_style = fill_style_map[self.fill_style] symbol = self.symbol dc.SetPen(wx.wxPen(color,weight)) dc.SetBrush(wx.wxBrush(fill_color,fill_style)) self._drawmarkers(dc, self.scaled, symbol, size) dc.SetPen(wx.wxNullPen) dc.SetBrush(wx.wxNullBrush) def _drawmarkers(self, dc, coords, marker,size=1): f = eval('self._' +marker) for xc, yc in coords: f(dc, xc, yc, size) def _circle(self, dc, xc, yc, size=1): ##dc.DrawEllipse(xc-3*size,yc-3*size,6*size,6*size) #mod by GAP 26092003 dc.DrawEllipse(int(xc-3*size),int(yc-3*size),6*size,6*size) def _dot(self, dc, xc, yc, size=1): dc.DrawPoint(xc,yc) def _square(self, dc, xc, yc, size=1): dc.DrawRectangle(xc-3*size,yc-3*size,6*size,6*size) def _triangle(self, dc, xc, yc, size=1): dc.DrawPolygon([(-0.5*size*6,0.2886751*size*6), (0.5*size*6,0.2886751*size*6), (0.0,-0.577350*size*6)],xc,yc) def _down_triangle(self, dc, xc, yc, size=1): dc.DrawPolygon([(-0.5*size*6,-0.2886751*size*6), (0.5*size*6,-0.2886751*size*6), (0.0,0.577350*size*6)],xc,yc) def _cross(self, dc, xc, yc, size=1): dc.DrawLine(xc-3*size,yc-3*size,xc+3*size,yc+3*size) dc.DrawLine(xc-3*size,yc+3*size,xc+3*size,yc-3*size) def _plus(self, dc, xc, yc, size=1): dc.DrawLine(xc-3*size,yc,xc+3*size,yc) dc.DrawLine(xc,yc-3*size,xc,yc+3*size) class line_object(poly_points): """ Combines poly_line and poly_marker into a single class """ _attributes = { 'color': ['auto',['auto','custom'],"'auto' or 'custom'."], 'marker_type':['auto',['auto','custom'],"'auto' or 'custom'."], 'line_type': ['auto',['auto','custom'],"'auto' or 'custom'."], 'name': ['','text string that identifies line'], } def __init__(self,points,**attr): poly_points.__init__(self,points,attr) self.markers = poly_marker(points) self.line = poly_line(points) def clip_box(self,box): self.clip = box.left(),box.top(),box.width(),box.height() def draw(self,dc): if hasattr(self,'clip'): c = self.clip ##dc.SetClippingRegion(c[0]-1,c[1]-1,c[2]+2,c[3]+2) # mod by GAP 26092003 dc.SetClippingRegion(int(c[0]-1),int(c[1]-1),int(c[2]+2),int(c[3]+2)) self.line.draw(dc) if hasattr(self,'clip'): dc.DestroyClippingRegion() if hasattr(self,'clip'): c = self.clip ##dc.SetClippingRegion(c[0]-5,c[1]-5,c[2]+10,c[3]+10) # mod by GAP 26092003 dc.SetClippingRegion(int(c[0]-5),int(c[1]-5),int(c[2]+10),int(c[3]+10)) self.markers.draw(dc) if hasattr(self,'clip'): dc.DestroyClippingRegion() def scale_and_shift(self, scale=1, shift=0): self.markers.scale_and_shift(scale, shift) self.line.scale_and_shift(scale, shift) def set_color(self,color): self.line.color = color self.markers.outline_color = color self.markers.fill_color = color class image_object(property_object): _attributes = { 'colormap': ['grey',[],"name of colormap or Nx3 color array"], 'scale': ['yes',['yes','no'],"Turn scaling on/off"], } def __init__(self, matrix,x_bounds=None,y_bounds=None,**attr): property_object.__init__(self,attr) if not x_bounds: self.x_bounds = array((0,matrix.shape[1])) else: # works for both 2 element or N element x self.x_bounds = array((x_bounds[0],x_bounds[-1])) if not y_bounds: self.y_bounds = array((0,matrix.shape[0])) else: self.y_bounds = array((y_bounds[0],y_bounds[-1])) self.matrix = matrix self.the_image = self.form_image() axis_lengths = array((self.x_bounds[1]-self.x_bounds[0], self.y_bounds[1]-self.y_bounds[0])) self.image_pixels_per_axis_unit =array((matrix.shape[1], matrix.shape[0]),Float)/axis_lengths self.image_origin = array((self.x_bounds[0],self.y_bounds[0])) def scale_magnitude(self,image,colormap): themin = float(minimum.reduce(ravel(image))) themax = float(maximum.reduce(ravel(image))) scaled = (image - themin) / (themax-themin) * len(colormap) *.99999 scaled = scaled.astype('b') return scaled def form_image(self): # look up colormap if it si identified by a string if type(self.colormap) == type(''): try: colormap = colormap_map[self.colormap] except KeyError: raise KeyError, 'Invalid colormap name. Choose from %s' \ % `colormap_map.keys()` else: colormap = self.colormap # scale image if we're supposed to. if self.scale in ['yes','on']: scaled_mag = self.scale_magnitude(self.matrix,colormap) else: scaled_mag = self.matrix.astype('b') scaled_mag = clip(scaled_mag,0,len(colormap)-1) if float(maximum.reduce(ravel(colormap))) == 1.: cmap = colormap * 255 else: cmap = colormap pixels = take( cmap, scaled_mag, 0) del scaled_mag # need to transpose pixels in memory... bitmap = pixels.astype(UnsignedInt8).tostring() image = wx.wxEmptyImage(self.matrix.shape[1],self.matrix.shape[0]) image.SetData(bitmap) return image def bounding_box(self): bb = array((self.x_bounds[0],self.y_bounds[0])), \ array((self.x_bounds[1],self.y_bounds[1])) return bb def scale_and_shift(self, scale=1, shift=0,upperleft=None,size=None): if scale is 1: scale = array((1,1)) if shift is 0: shift = array((0,0)) graph_pixels_per_axis_unit = scale self.scale = graph_pixels_per_axis_unit/self.image_pixels_per_axis_unit self.origin = shift self.graph_upperleft = upperleft self.graph_size = size def draw(self,dc): sz = array((self.the_image.GetWidth(),self.the_image.GetHeight())) sz = sz* self.scale sz = abs(sz.astype(Int)) scaled_image = self.the_image.Scale(sz[0],sz[1]) bitmap = scaled_image.ConvertToBitmap() dc.DrawBitmap(bitmap, self.origin[0]+1, self.origin[1]-scaled_image.GetHeight()+1, wx.false) import UserList huge = array((1e308,1e308)) tiny = array((-1e308,-1e308)) class graphic_list(UserList.UserList): """ probably should have a layout method """ def __init__(self): UserList.UserList.__init__(self) def bounding_box(self): p1 =[]; p2 = [] for o in self.data: p1o, p2o = o.bounding_box() p1.append(p1o);p2.append(p2o) if len(p1): return minimum.reduce(p1), maximum.reduce(p2) else: # so big or small that they always loose to other data sets return huge,tiny def axis_bounds(self): p1, p2 = self.bounding_box() return array((p1[0],p2[0])), array((p1[1],p2[1])) def scale_and_shift(self, scale=1, shift=0): for o in self.data: o.scale_and_shift(scale, shift) def draw(self, canvas): for o in self.data: o.draw(canvas) auto_styles = [['blue','circle','solid'], ['green','square','solid'], ['red','triangle','solid'],['cyan','down_triangle','solid'], ['orange','cross','solid'],['purple','plus','solid'] ] # make a black and white auto? class auto_line_list(graphic_list): """ Handles drawing of line_objects with auto styles only works with line_objects """ def clip_box(self,box): for o in self.data: o.clip_box(box) def draw(self, canvas): idx = 0 for o in self.data: #print 'line vis before:',o.line_type, o.line.visible #print 'marker vis before:',o.marker_type, o.markers.visible if 'auto' in [o.color,o.line_type,o.marker_type]: if idx >= len(auto_styles): idx = 0 color,marker,line_type = auto_styles[idx] #print 'clm: ',color,marker,line_type if 'auto' == o.color: o.set_color(color) if 'auto' == o.marker_type and marker: o.markers.symbol = marker o.markers.visible = 'yes' if 'auto' == o.line_type and line_type: o.line.style = line_type o.line.visible = 'yes' idx = idx + 1 #print 'line vis after:',o.line_type, o.line.visible #print 'marker vis after:',o.marker_type, o.markers.visible o.draw(canvas)