2012-01-23 11:36:49 +00:00
|
|
|
# This file is part of the Printrun suite.
|
|
|
|
#
|
|
|
|
# Printrun is free software: you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License as published by
|
|
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
|
|
# (at your option) any later version.
|
|
|
|
#
|
|
|
|
# Printrun is distributed in the hope that it will be useful,
|
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with Printrun. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2011-06-21 16:52:11 +00:00
|
|
|
import wx,time
|
|
|
|
|
|
|
|
class window(wx.Frame):
|
2011-12-11 09:11:47 +00:00
|
|
|
def __init__(self,f,size=(600,600),build_dimensions=[200,200,100,0,0,0],grid=(10,50),extrusion_width=0.5):
|
2011-12-03 22:05:30 +00:00
|
|
|
wx.Frame.__init__(self,None,title="Gcode view, shift to move view, mousewheel to set layer",size=(size[0],size[1]))
|
2011-12-11 09:11:47 +00:00
|
|
|
self.p=gviz(self,size=size,build_dimensions=build_dimensions,grid=grid,extrusion_width=extrusion_width)
|
2011-06-21 16:52:11 +00:00
|
|
|
s=time.time()
|
2011-06-22 12:54:59 +00:00
|
|
|
#print time.time()-s
|
2011-07-15 07:15:12 +00:00
|
|
|
self.initpos=[0,0]
|
2011-06-21 16:52:11 +00:00
|
|
|
self.p.Bind(wx.EVT_KEY_DOWN,self.key)
|
2011-06-24 23:28:36 +00:00
|
|
|
self.Bind(wx.EVT_KEY_DOWN,self.key)
|
2011-06-26 17:46:03 +00:00
|
|
|
self.p.Bind(wx.EVT_MOUSEWHEEL,self.zoom)
|
|
|
|
self.Bind(wx.EVT_MOUSEWHEEL,self.zoom)
|
2011-07-15 07:15:12 +00:00
|
|
|
self.p.Bind(wx.EVT_MOUSE_EVENTS,self.mouse)
|
|
|
|
self.Bind(wx.EVT_MOUSE_EVENTS,self.mouse)
|
2011-12-03 22:05:30 +00:00
|
|
|
|
2011-07-15 07:15:12 +00:00
|
|
|
def mouse(self,event):
|
|
|
|
if event.ButtonUp(wx.MOUSE_BTN_LEFT):
|
|
|
|
if(self.initpos is not None):
|
|
|
|
self.initpos=None
|
|
|
|
elif event.Dragging():
|
|
|
|
e=event.GetPositionTuple()
|
2011-07-26 12:47:47 +00:00
|
|
|
if self.initpos is None or not hasattr(self,"basetrans"):
|
2011-07-15 07:15:12 +00:00
|
|
|
self.initpos=e
|
|
|
|
self.basetrans=self.p.translate
|
|
|
|
#print self.p.translate,e,self.initpos
|
|
|
|
self.p.translate = [ self.basetrans[0]+(e[0]-self.initpos[0]),
|
|
|
|
self.basetrans[1]+(e[1]-self.initpos[1]) ]
|
|
|
|
self.p.repaint()
|
|
|
|
self.p.Refresh()
|
|
|
|
|
|
|
|
else:
|
|
|
|
event.Skip()
|
|
|
|
|
2011-06-21 16:52:11 +00:00
|
|
|
def key(self, event):
|
|
|
|
x=event.GetKeyCode()
|
|
|
|
#print x
|
|
|
|
if x==wx.WXK_UP:
|
|
|
|
self.p.layerup()
|
|
|
|
if x==wx.WXK_DOWN:
|
|
|
|
self.p.layerdown()
|
|
|
|
|
|
|
|
#print p.lines.keys()
|
2011-06-26 17:46:03 +00:00
|
|
|
def zoom(self, event):
|
2011-07-10 09:57:11 +00:00
|
|
|
z=event.GetWheelRotation()
|
|
|
|
if event.ShiftDown():
|
|
|
|
if z > 0: self.p.layerdown()
|
|
|
|
elif z < 0: self.p.layerup()
|
|
|
|
else:
|
|
|
|
if z > 0: self.p.zoom(event.GetX(),event.GetY(),1.2)
|
|
|
|
elif z < 0: self.p.zoom(event.GetX(),event.GetY(),1/1.2)
|
2011-06-21 16:52:11 +00:00
|
|
|
|
|
|
|
class gviz(wx.Panel):
|
2011-12-11 09:11:47 +00:00
|
|
|
def __init__(self,parent,size=(200,200),build_dimensions=[200,200,100,0,0,0],grid=(10,50),extrusion_width=0.5):
|
2011-09-02 08:56:07 +00:00
|
|
|
wx.Panel.__init__(self,parent,-1,size=(size[0],size[1]))
|
2011-06-22 12:54:59 +00:00
|
|
|
self.size=size
|
2011-12-11 09:11:47 +00:00
|
|
|
self.build_dimensions=build_dimensions
|
2011-08-07 20:00:13 +00:00
|
|
|
self.grid=grid
|
2011-11-07 09:38:51 +00:00
|
|
|
self.lastpos=[0,0,0,0,0,0,0]
|
2011-06-22 11:40:27 +00:00
|
|
|
self.hilightpos=self.lastpos[:]
|
2011-06-21 16:52:11 +00:00
|
|
|
self.Bind(wx.EVT_PAINT,self.paint)
|
2011-11-30 20:49:31 +00:00
|
|
|
self.Bind(wx.EVT_SIZE,self.resize)
|
2011-06-21 16:52:11 +00:00
|
|
|
self.lines={}
|
|
|
|
self.pens={}
|
2011-11-07 09:38:51 +00:00
|
|
|
self.arcs={}
|
|
|
|
self.arcpens={}
|
2011-06-21 16:52:11 +00:00
|
|
|
self.layers=[]
|
|
|
|
self.layerindex=0
|
2011-08-07 20:11:35 +00:00
|
|
|
self.filament_width=extrusion_width # set it to 0 to disable scaling lines with zoom
|
2011-12-11 10:04:08 +00:00
|
|
|
self.basescale=[min(float(size[0])/build_dimensions[0],float(size[1])/build_dimensions[1])]*2
|
2011-11-30 20:49:31 +00:00
|
|
|
self.scale=self.basescale
|
2011-07-26 12:47:47 +00:00
|
|
|
penwidth = max(1.0,self.filament_width*((self.scale[0]+self.scale[1])/2.0))
|
|
|
|
self.translate=[0.0,0.0]
|
|
|
|
self.mainpen=wx.Pen(wx.Colour(0,0,0),penwidth)
|
2011-11-07 12:04:21 +00:00
|
|
|
self.arcpen=wx.Pen(wx.Colour(255,0,0),penwidth)
|
2011-09-07 11:43:36 +00:00
|
|
|
self.travelpen=wx.Pen(wx.Colour(10,80,80),penwidth)
|
2011-07-26 12:47:47 +00:00
|
|
|
self.hlpen=wx.Pen(wx.Colour(200,50,50),penwidth)
|
|
|
|
self.fades=[wx.Pen(wx.Colour(250-0.6**i*100,250-0.6**i*100,200-0.4**i*50),penwidth) for i in xrange(6)]
|
2011-09-07 11:43:36 +00:00
|
|
|
self.penslist=[self.mainpen,self.travelpen,self.hlpen]+self.fades
|
2011-06-21 16:52:11 +00:00
|
|
|
self.showall=0
|
2011-06-22 10:21:04 +00:00
|
|
|
self.hilight=[]
|
2011-11-07 09:38:51 +00:00
|
|
|
self.hilightarcs=[]
|
2011-06-29 20:17:53 +00:00
|
|
|
self.dirty=1
|
|
|
|
self.blitmap=wx.EmptyBitmap(self.GetClientSize()[0],self.GetClientSize()[1],-1)
|
2011-06-21 16:52:11 +00:00
|
|
|
|
|
|
|
def clear(self):
|
2011-11-07 09:38:51 +00:00
|
|
|
self.lastpos=[0,0,0,0,0,0,0]
|
2011-06-21 16:52:11 +00:00
|
|
|
self.lines={}
|
|
|
|
self.pens={}
|
2011-11-22 18:08:00 +00:00
|
|
|
self.arcs={}
|
|
|
|
self.arcpens={}
|
2011-06-21 16:52:11 +00:00
|
|
|
self.layers=[]
|
2011-11-22 18:08:00 +00:00
|
|
|
self.hilight=[]
|
|
|
|
self.hilightarcs=[]
|
2011-06-21 16:52:11 +00:00
|
|
|
self.layerindex=0
|
|
|
|
self.showall=0
|
2011-06-29 20:17:53 +00:00
|
|
|
self.dirty=1
|
2011-07-10 09:57:11 +00:00
|
|
|
#self.repaint()
|
2011-06-21 16:52:11 +00:00
|
|
|
def layerup(self):
|
|
|
|
if(self.layerindex+1<len(self.layers)):
|
|
|
|
self.layerindex+=1
|
2011-06-29 20:17:53 +00:00
|
|
|
self.repaint()
|
2011-06-21 16:52:11 +00:00
|
|
|
self.Refresh()
|
|
|
|
|
|
|
|
def layerdown(self):
|
|
|
|
if(self.layerindex>0):
|
|
|
|
self.layerindex-=1
|
2011-06-29 20:17:53 +00:00
|
|
|
self.repaint()
|
2011-06-21 16:52:11 +00:00
|
|
|
self.Refresh()
|
2011-06-22 10:21:04 +00:00
|
|
|
|
|
|
|
def setlayer(self,layer):
|
|
|
|
try:
|
|
|
|
self.layerindex=self.layers.index(layer)
|
2011-06-29 20:17:53 +00:00
|
|
|
self.repaint()
|
2011-06-22 10:21:04 +00:00
|
|
|
wx.CallAfter(self.Refresh)
|
|
|
|
self.showall=0
|
|
|
|
except:
|
|
|
|
pass
|
2011-06-29 20:17:53 +00:00
|
|
|
|
2011-11-30 20:49:31 +00:00
|
|
|
def resize(self,event):
|
|
|
|
size=self.GetClientSize()
|
|
|
|
newsize=min(float(size[0])/self.size[0],float(size[1])/self.size[1])
|
|
|
|
self.size=self.GetClientSize()
|
|
|
|
wx.CallAfter(self.zoom,0,0,newsize)
|
|
|
|
|
2011-06-22 10:21:04 +00:00
|
|
|
|
2011-06-26 17:46:03 +00:00
|
|
|
def zoom(self,x,y,factor):
|
2011-07-10 09:57:11 +00:00
|
|
|
self.scale = [s * factor for s in self.scale]
|
2011-11-30 20:49:31 +00:00
|
|
|
|
2011-07-10 09:57:11 +00:00
|
|
|
self.translate = [ x - (x-self.translate[0]) * factor,
|
|
|
|
y - (y-self.translate[1]) * factor]
|
2011-07-26 12:47:47 +00:00
|
|
|
penwidth = max(1.0,self.filament_width*((self.scale[0]+self.scale[1])/2.0))
|
|
|
|
for pen in self.penslist:
|
|
|
|
pen.SetWidth(penwidth)
|
2011-07-10 09:57:11 +00:00
|
|
|
#self.dirty=1
|
2011-06-29 20:17:53 +00:00
|
|
|
self.repaint()
|
|
|
|
self.Refresh()
|
2011-09-02 08:56:07 +00:00
|
|
|
|
2011-11-30 20:49:31 +00:00
|
|
|
|
2011-06-29 20:17:53 +00:00
|
|
|
def repaint(self):
|
2011-09-02 08:56:07 +00:00
|
|
|
self.blitmap=wx.EmptyBitmap(self.GetClientSize()[0],self.GetClientSize()[1],-1)
|
2011-06-29 20:17:53 +00:00
|
|
|
dc=wx.MemoryDC()
|
|
|
|
dc.SelectObject(self.blitmap)
|
2011-06-21 16:52:11 +00:00
|
|
|
dc.SetBackground(wx.Brush((250,250,200)))
|
|
|
|
dc.Clear()
|
2011-08-07 20:00:13 +00:00
|
|
|
dc.SetPen(wx.Pen(wx.Colour(180,180,150)))
|
|
|
|
for grid_unit in self.grid:
|
|
|
|
if grid_unit > 0:
|
2011-12-11 09:11:47 +00:00
|
|
|
for x in xrange(int(self.build_dimensions[0]/grid_unit)+1):
|
|
|
|
dc.DrawLine(self.translate[0]+x*self.scale[0]*grid_unit,self.translate[1],self.translate[0]+x*self.scale[0]*grid_unit,self.translate[1]+self.scale[1]*self.build_dimensions[1])
|
|
|
|
for y in xrange(int(self.build_dimensions[1]/grid_unit)+1):
|
|
|
|
dc.DrawLine(self.translate[0],self.translate[1]+y*self.scale[1]*grid_unit,self.translate[0]+self.scale[0]*self.build_dimensions[0],self.translate[1]+y*self.scale[1]*grid_unit)
|
2011-08-07 20:00:13 +00:00
|
|
|
dc.SetPen(wx.Pen(wx.Colour(0,0,0)))
|
2011-06-24 23:28:36 +00:00
|
|
|
if not self.showall:
|
2011-07-26 12:47:47 +00:00
|
|
|
self.size = self.GetSize()
|
2011-06-24 23:28:36 +00:00
|
|
|
dc.SetBrush(wx.Brush((43,144,255)))
|
|
|
|
dc.DrawRectangle(self.size[0]-15,0,15,self.size[1])
|
|
|
|
dc.SetBrush(wx.Brush((0,255,0)))
|
|
|
|
if len(self.layers):
|
|
|
|
dc.DrawRectangle(self.size[0]-14,(1.0-(1.0*(self.layerindex+1))/len(self.layers))*self.size[1],13,self.size[1]-1)
|
2011-11-07 09:38:51 +00:00
|
|
|
|
|
|
|
def _drawlines(lines,pens):
|
|
|
|
def _scaler(x):
|
|
|
|
return (self.scale[0]*x[0]+self.translate[0],
|
|
|
|
self.scale[1]*x[1]+self.translate[1],
|
|
|
|
self.scale[0]*x[2]+self.translate[0],
|
|
|
|
self.scale[1]*x[3]+self.translate[1],)
|
|
|
|
scaled_lines = map(_scaler,lines)
|
|
|
|
dc.DrawLineList(scaled_lines, pens)
|
|
|
|
|
|
|
|
def _drawarcs(arcs,pens):
|
|
|
|
def _scaler(x):
|
|
|
|
return (self.scale[0]*x[0]+self.translate[0],
|
|
|
|
self.scale[1]*x[1]+self.translate[1],
|
|
|
|
self.scale[0]*x[2]+self.translate[0],
|
|
|
|
self.scale[1]*x[3]+self.translate[1],
|
|
|
|
self.scale[0]*x[4]+self.translate[0],
|
|
|
|
self.scale[1]*x[5]+self.translate[1],)
|
|
|
|
scaled_arcs = map(_scaler,arcs)
|
|
|
|
for i in range(len(scaled_arcs)):
|
|
|
|
dc.SetPen(pens[i] if type(pens).__name__ == 'list' else pens)
|
|
|
|
dc.SetBrush(wx.TRANSPARENT_BRUSH)
|
|
|
|
dc.DrawArc(*scaled_arcs[i])
|
|
|
|
|
2011-06-21 16:52:11 +00:00
|
|
|
if self.showall:
|
|
|
|
l=[]
|
|
|
|
for i in self.layers:
|
|
|
|
dc.DrawLineList(l,self.fades[0])
|
2011-11-07 09:38:51 +00:00
|
|
|
_drawlines(self.lines[i], self.pens[i])
|
|
|
|
_drawarcs(self.arcs[i], self.arcpens[i])
|
2011-06-21 16:52:11 +00:00
|
|
|
return
|
|
|
|
if self.layerindex<len(self.layers) and self.layers[self.layerindex] in self.lines.keys():
|
2011-07-28 09:54:06 +00:00
|
|
|
for layer_i in xrange(max(0,self.layerindex-6),self.layerindex):
|
2011-06-21 16:52:11 +00:00
|
|
|
#print i, self.layerindex, self.layerindex-i
|
2011-11-07 09:38:51 +00:00
|
|
|
_drawlines(self.lines[self.layers[layer_i]], self.fades[self.layerindex-layer_i-1])
|
|
|
|
_drawarcs(self.arcs[self.layers[layer_i]], self.fades[self.layerindex-layer_i-1])
|
|
|
|
_drawlines(self.lines[self.layers[self.layerindex]], self.pens[self.layers[self.layerindex]])
|
|
|
|
_drawarcs(self.arcs[self.layers[self.layerindex]], self.arcpens[self.layers[self.layerindex]])
|
|
|
|
|
|
|
|
_drawlines(self.hilight, self.hlpen)
|
|
|
|
_drawarcs(self.hilightarcs, self.hlpen)
|
|
|
|
|
2011-06-29 20:17:53 +00:00
|
|
|
dc.SelectObject(wx.NullBitmap)
|
|
|
|
|
|
|
|
def paint(self,event):
|
|
|
|
dc=wx.PaintDC(self)
|
|
|
|
if(self.dirty):
|
|
|
|
self.repaint()
|
|
|
|
self.dirty=0
|
|
|
|
sz=self.GetClientSize()
|
|
|
|
dc.DrawBitmap(self.blitmap,0,0)
|
2011-06-21 16:52:11 +00:00
|
|
|
del dc
|
|
|
|
|
2011-12-03 22:05:30 +00:00
|
|
|
def addfile(self,gcodes=[]):
|
|
|
|
self.clear()
|
|
|
|
for i in gcodes:
|
|
|
|
self.addgcode(i)
|
|
|
|
|
2011-06-22 11:40:27 +00:00
|
|
|
def addgcode(self,gcode="M105",hilight=0):
|
|
|
|
gcode=gcode.split("*")[0]
|
2011-06-30 12:05:53 +00:00
|
|
|
gcode=gcode.split(";")[0]
|
2011-11-07 09:38:51 +00:00
|
|
|
gcode = gcode.lower().strip().split()
|
|
|
|
if len(gcode) == 0:
|
|
|
|
return
|
2011-12-07 11:22:45 +00:00
|
|
|
if gcode[0][0] == 'n':
|
|
|
|
gcode.pop(0)
|
2011-11-07 09:38:51 +00:00
|
|
|
|
|
|
|
def _readgcode():
|
2011-06-21 16:52:11 +00:00
|
|
|
target=self.lastpos[:]
|
2011-06-22 11:40:27 +00:00
|
|
|
if hilight:
|
|
|
|
target=self.hilightpos[:]
|
2011-06-21 16:52:11 +00:00
|
|
|
for i in gcode:
|
|
|
|
if i[0]=="x":
|
|
|
|
target[0]=float(i[1:])
|
|
|
|
elif i[0]=="y":
|
|
|
|
target[1]=float(i[1:])
|
|
|
|
elif i[0]=="z":
|
|
|
|
target[2]=float(i[1:])
|
|
|
|
elif i[0]=="e":
|
|
|
|
target[3]=float(i[1:])
|
|
|
|
elif i[0]=="f":
|
|
|
|
target[4]=float(i[1:])
|
2011-11-07 09:38:51 +00:00
|
|
|
elif i[0]=="i":
|
|
|
|
target[5]=float(i[1:])
|
|
|
|
elif i[0]=="j":
|
|
|
|
target[6]=float(i[1:])
|
2011-06-22 11:40:27 +00:00
|
|
|
if not hilight:
|
|
|
|
if not target[2] in self.lines.keys():
|
|
|
|
self.lines[target[2]]=[]
|
|
|
|
self.pens[target[2]]=[]
|
2011-11-07 09:38:51 +00:00
|
|
|
self.arcs[target[2]]=[]
|
|
|
|
self.arcpens[target[2]]=[]
|
2011-06-22 11:40:27 +00:00
|
|
|
self.layers+=[target[2]]
|
2011-11-07 09:38:51 +00:00
|
|
|
return target
|
|
|
|
|
|
|
|
def _y(y):
|
2011-12-11 09:11:47 +00:00
|
|
|
return self.build_dimensions[1]-(y-self.build_dimensions[4])
|
2011-12-10 14:04:53 +00:00
|
|
|
def _x(x):
|
2011-12-11 09:11:47 +00:00
|
|
|
return x-self.build_dimensions[3]
|
2011-11-07 09:38:51 +00:00
|
|
|
|
|
|
|
start_pos = self.hilightpos[:] if hilight else self.lastpos[:]
|
|
|
|
|
2012-02-06 20:46:08 +00:00
|
|
|
if gcode[0] in [ "g0", "g1" ]:
|
2011-11-07 09:38:51 +00:00
|
|
|
target = _readgcode()
|
2011-12-10 14:04:53 +00:00
|
|
|
line = [ _x(start_pos[0]), _y(start_pos[1]), _x(target[0]), _y(target[1]) ]
|
2011-11-07 09:38:51 +00:00
|
|
|
if not hilight:
|
|
|
|
self.lines[ target[2] ] += [line]
|
|
|
|
self.pens[ target[2] ] += [self.mainpen if target[3] != self.lastpos[3] else self.travelpen]
|
|
|
|
self.lastpos = target
|
2011-06-22 11:40:27 +00:00
|
|
|
else:
|
2011-11-13 22:08:06 +00:00
|
|
|
self.hilight += [line]
|
2011-11-07 09:38:51 +00:00
|
|
|
self.hilightpos = target
|
|
|
|
self.dirty = 1
|
|
|
|
|
|
|
|
if gcode[0] in [ "g2", "g3" ]:
|
|
|
|
target = _readgcode()
|
|
|
|
arc = []
|
2011-12-10 14:04:53 +00:00
|
|
|
arc += [ _x(start_pos[0]), _y(start_pos[1]) ]
|
|
|
|
arc += [ _x(target[0]), _y(target[1]) ]
|
|
|
|
arc += [ _x(start_pos[0] + target[5]), _y(start_pos[1] + target[6]) ] # center
|
2011-11-07 09:38:51 +00:00
|
|
|
if gcode[0] == "g2": # clockwise, reverse endpoints
|
|
|
|
arc[0], arc[1], arc[2], arc[3] = arc[2], arc[3], arc[0], arc[1]
|
2011-06-21 16:52:11 +00:00
|
|
|
|
2011-11-07 09:38:51 +00:00
|
|
|
if not hilight:
|
|
|
|
self.arcs[ target[2] ] += [arc]
|
2011-11-07 12:04:21 +00:00
|
|
|
self.arcpens[ target[2] ] += [self.arcpen]
|
2011-11-07 09:38:51 +00:00
|
|
|
self.lastpos = target
|
|
|
|
else:
|
2011-11-13 22:08:06 +00:00
|
|
|
self.hilightarcs += [arc]
|
2011-11-07 09:38:51 +00:00
|
|
|
self.hilightpos = target
|
|
|
|
self.dirty = 1
|
2011-06-21 16:52:11 +00:00
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
app = wx.App(False)
|
2011-07-31 07:57:15 +00:00
|
|
|
#main = window(open("/home/kliment/designs/spinner/arm_export.gcode"))
|
|
|
|
main = window(open("jam.gcode"))
|
2011-06-21 16:52:11 +00:00
|
|
|
main.Show()
|
|
|
|
app.MainLoop()
|
|
|
|
|