|
|
@@ -0,0 +1,3185 @@
|
|
|
+import collections
|
|
|
+from collections import defaultdict, Counter
|
|
|
+from itertools import compress,izip, cycle
|
|
|
+import itertools
|
|
|
+import pcbnew
|
|
|
+import time
|
|
|
+import os, sys
|
|
|
+import math
|
|
|
+import re
|
|
|
+from textwrap import wrap
|
|
|
+import wx
|
|
|
+from wxpointutil import wxPointUtil
|
|
|
+import kicommand_gui
|
|
|
+
|
|
|
+_dictionary = {'user':{}, 'persist':{}, 'command':{}}
|
|
|
+
|
|
|
+_command_dictionary = _dictionary ['command']
|
|
|
+stack = []
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+Command = collections.namedtuple('Command','numoperands execute category helptext')
|
|
|
+UserCommand = collections.namedtuple('UserCommand','execute category helptext')
|
|
|
+
|
|
|
+DrawParams = collections.namedtuple('DrawParams','t w h l zt zp')
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def SHOWPARAM(values,keys):
|
|
|
+ return _user_stacks['drawparams']
|
|
|
+
|
|
|
+def PARAM(values,keys):
|
|
|
+ if isinstance(values,basestring):
|
|
|
+ values = values.split(',')
|
|
|
+ keys = keys.split(',')
|
|
|
+
|
|
|
+ if not hasattr(values,'__iter__'):
|
|
|
+ values = [values]
|
|
|
+ for k,v in zip(keys,values):
|
|
|
+ _user_stacks['drawparams'][k] = v
|
|
|
+
|
|
|
+class gui(kicommand_gui.kicommand_panel):
|
|
|
+ """Inherits from the form wxFormBuilder. Supplies
|
|
|
+ functions that tie the gui to the functions below."""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ combolist = []
|
|
|
+
|
|
|
+ def process(self,e):
|
|
|
+ try:
|
|
|
+ commandstring = self.entrybox.GetValue()
|
|
|
+ run(commandstring)
|
|
|
+ self.entrybox.Clear()
|
|
|
+ self.outputbox.ShowPosition(self.outputbox.GetLastPosition())
|
|
|
+ if commandstring != '':
|
|
|
+ self.combolist.insert(0,commandstring)
|
|
|
+ self.entrybox.SetItems(self.combolist)
|
|
|
+
|
|
|
+ self.entrybox.SetFocus()
|
|
|
+
|
|
|
+ self.entrybox.Update()
|
|
|
+ except Exception as e:
|
|
|
+ exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
|
+ fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
|
|
|
+
|
|
|
+ output(str(e))
|
|
|
+ wx.MessageDialog(self.GetParent(),"Error 1 on line %s: %s"%
|
|
|
+ (exc_tb.tb_lineno,str(e))).ShowModal()
|
|
|
+
|
|
|
+class aplugin(pcbnew.ActionPlugin):
|
|
|
+ """implements ActionPlugin"""
|
|
|
+ g = None
|
|
|
+ def defaults(self):
|
|
|
+ self.name = "KiCommand"
|
|
|
+ self.category = "Command"
|
|
|
+ self.description = "Select, modify and interrogate pcbnew objects with a simple command script."
|
|
|
+ def Run(self):
|
|
|
+ parent = \
|
|
|
+ filter(lambda w: w.GetTitle().startswith('Pcbnew'),
|
|
|
+ wx.GetTopLevelWindows()
|
|
|
+ )[0]
|
|
|
+ aplugin.g=gui(parent)
|
|
|
+ pane = wx.aui.AuiPaneInfo() \
|
|
|
+ .Caption( u"KiCommand" ) \
|
|
|
+ .Center() \
|
|
|
+ .Float() \
|
|
|
+ .FloatingPosition( wx.Point( 346,268 ) ) \
|
|
|
+ .Resizable() \
|
|
|
+ .FloatingSize( wx.Size( int(610),int(652) ) ) \
|
|
|
+ .Layer( 0 )
|
|
|
+
|
|
|
+ manager = wx.aui.AuiManager.GetManager(parent)
|
|
|
+ manager.AddPane( self.__class__.g, pane )
|
|
|
+ manager.Update()
|
|
|
+ loadname = os.path.join(os.path.dirname(__file__),'kicommand_persist.commands')
|
|
|
+
|
|
|
+ LOAD('kicommand_persist.commands',path=os.path.dirname(__file__))
|
|
|
+
|
|
|
+ run('help')
|
|
|
+
|
|
|
+
|
|
|
+def run(commandstring,returnval=0):
|
|
|
+ """returnval -1 return entire stack, 0 return top, >0 return that number of elements from top of list as a list."""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ global stack
|
|
|
+ global _compile_mode
|
|
|
+ global _command_definition
|
|
|
+ global _user_dictionary
|
|
|
+ global _dictionary
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ commandlines = commandstring.splitlines()
|
|
|
+ commands = []
|
|
|
+ for commandstring in commandlines:
|
|
|
+
|
|
|
+
|
|
|
+ qend = 0
|
|
|
+ while True:
|
|
|
+ qindex = commandstring.find('"',qend)
|
|
|
+ if qindex == -1:
|
|
|
+ break;
|
|
|
+
|
|
|
+ commands.extend(commandstring[qend:qindex].split())
|
|
|
+ qend = commandstring.find('"',qindex+1)
|
|
|
+ if qend == -1:
|
|
|
+ raise SyntaxError('A line must contain an even number of double quotes.')
|
|
|
+ commands.append(commandstring[qindex+1:qend])
|
|
|
+
|
|
|
+ qend += 1
|
|
|
+
|
|
|
+
|
|
|
+ commands.extend(commandstring[qend:].split())
|
|
|
+
|
|
|
+
|
|
|
+ for command in commands:
|
|
|
+
|
|
|
+ if command == ';':
|
|
|
+ _compile_mode = False
|
|
|
+ comm = _command_definition[:1]
|
|
|
+ if not comm:
|
|
|
+ _user_dictionary = {}
|
|
|
+ continue
|
|
|
+ comm = comm[0]
|
|
|
+ cdef = _command_definition[1:]
|
|
|
+ if cdef:
|
|
|
+
|
|
|
+
|
|
|
+ cat = ''
|
|
|
+ help = ''
|
|
|
+ firstspace = cdef[0].find(' ')
|
|
|
+ if firstspace != -1:
|
|
|
+ cathelp = cdef.pop(0)
|
|
|
+ cat = cathelp[:firstspace]
|
|
|
+ help = cathelp[firstspace+1:]
|
|
|
+ _dictionary[_newcommanddictionary][comm] = UserCommand(cdef,cat,help)
|
|
|
+
|
|
|
+ else:
|
|
|
+ _dictionary[_newcommanddictionary][comm] = UserCommand(cdef,'','')
|
|
|
+
|
|
|
+ else:
|
|
|
+ del(_user_dictionary[_command_definition[0]])
|
|
|
+ _command_definition = []
|
|
|
+ continue
|
|
|
+
|
|
|
+ if _compile_mode:
|
|
|
+ _command_definition.append(command)
|
|
|
+ continue
|
|
|
+
|
|
|
+ if command.startswith("'"):
|
|
|
+ stack.append(command[1:])
|
|
|
+ continue
|
|
|
+
|
|
|
+ found = False
|
|
|
+
|
|
|
+ for dictname in ('user','persist','command'):
|
|
|
+
|
|
|
+ if command not in _dictionary[dictname]:
|
|
|
+ continue
|
|
|
+ commandToExecute = _dictionary[dictname][command]
|
|
|
+ if isinstance(commandToExecute,Command):
|
|
|
+
|
|
|
+ numop = commandToExecute.numoperands
|
|
|
+ if len(stack) < numop:
|
|
|
+ raise TypeError('%s expects %d arguments on the stack.'%(command,numop))
|
|
|
+ if numop:
|
|
|
+ result = commandToExecute.execute(stack[-numop:])
|
|
|
+ stack = stack[:-numop]
|
|
|
+ else:
|
|
|
+ result = commandToExecute.execute([])
|
|
|
+
|
|
|
+ if result != None:
|
|
|
+ stack.append(result)
|
|
|
+ elif isinstance(commandToExecute,UserCommand):
|
|
|
+
|
|
|
+ run(' '.join(commandToExecute.execute))
|
|
|
+ elif isinstance(commandToExecute,basestring):
|
|
|
+
|
|
|
+ run(commandToExecute)
|
|
|
+ found = True
|
|
|
+ break
|
|
|
+ if not found:
|
|
|
+ stack.append(command)
|
|
|
+
|
|
|
+
|
|
|
+ if len(stack):
|
|
|
+ output( len(stack), 'operands left on the stack.' )
|
|
|
+ try:
|
|
|
+ pcbnew.UpdateUserInterface()
|
|
|
+ except:
|
|
|
+ pass
|
|
|
+
|
|
|
+ if returnval == 0:
|
|
|
+ if stack:
|
|
|
+ return stack[-1]
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+ elif returnval == -1:
|
|
|
+ return stack
|
|
|
+ elif returnval > 0:
|
|
|
+
|
|
|
+ return stack[-returnval:]
|
|
|
+
|
|
|
+def retNone(function,*args):
|
|
|
+ function(*args)
|
|
|
+
|
|
|
+def UNDOCK():
|
|
|
+ wx.aui.AuiManager.GetManager(aplugin.g).GetPane(aplugin.g).Float()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def STACK():
|
|
|
+ for obj in stack:
|
|
|
+ output(obj)
|
|
|
+def PRINT():
|
|
|
+ """print the top of the stack"""
|
|
|
+ output(stack[-1])
|
|
|
+
|
|
|
+def CLEAR():
|
|
|
+ global stack
|
|
|
+ stack = []
|
|
|
+ return None
|
|
|
+
|
|
|
+def SWAP():
|
|
|
+ global stack
|
|
|
+ stack[-1],stack[-2]=stack[-2],stack[-1]
|
|
|
+
|
|
|
+def output(*args):
|
|
|
+
|
|
|
+ for arg in args:
|
|
|
+ aplugin.g.outputbox.AppendText(str(arg)+' ')
|
|
|
+ aplugin.g.outputbox.AppendText('\n')
|
|
|
+ return
|
|
|
+
|
|
|
+ for arg in args:
|
|
|
+ print arg,
|
|
|
+ print
|
|
|
+
|
|
|
+def tosegments(*c):
|
|
|
+ tracklist,layer = c
|
|
|
+
|
|
|
+ try:
|
|
|
+ layerID = int(layer)
|
|
|
+ except:
|
|
|
+ layerID = _user_stacks['Board'][-1].GetLayerID(str(layer))
|
|
|
+
|
|
|
+ segments = []
|
|
|
+ for tlist in tracklist:
|
|
|
+ for t in tlist:
|
|
|
+
|
|
|
+
|
|
|
+ s,e = get_ds_ends(t)
|
|
|
+
|
|
|
+ try:
|
|
|
+ width = t.GetWidth()
|
|
|
+ except:
|
|
|
+ width = _user_stacks['drawparams']['t']
|
|
|
+ if not isinstance(s,pcbnew.wxPoint):
|
|
|
+ s = pcbnew.wxPoint(*s)
|
|
|
+ if not isinstance(e,pcbnew.wxPoint):
|
|
|
+ e = pcbnew.wxPoint(*e)
|
|
|
+ segments.append(draw_segmentwx(
|
|
|
+ s,
|
|
|
+ e,
|
|
|
+ layer=layerID,
|
|
|
+ thickness=width))
|
|
|
+ return segments
|
|
|
+
|
|
|
+
|
|
|
+def draw_segmentlist(input,layer=pcbnew.Eco2_User,thickness=0.015*pcbnew.IU_PER_MM):
|
|
|
+ """Draws the vector (wxPoint_vector of polygon vertices) on the given
|
|
|
+ layer and with the given thickness.
|
|
|
+ close indicates whether the polygon needs to be closed
|
|
|
+ (close=False means the last point is equal to the first point).
|
|
|
+ The drawing will use this input to draw a closed polygon."""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ try:
|
|
|
+ layer = int(layer)
|
|
|
+ except:
|
|
|
+ layer = _user_stacks['Board'][-1].GetLayerID(str(layer))
|
|
|
+
|
|
|
+ if isinstance(input,basestring):
|
|
|
+
|
|
|
+ return drawlistofpolylines([input],layer,thickness)
|
|
|
+
|
|
|
+ if not hasattr(input,'__getitem__'):
|
|
|
+ input = list(input)
|
|
|
+
|
|
|
+ if isinstance(input[0],(float,int,pcbnew.wxPoint)):
|
|
|
+ input = [input]
|
|
|
+
|
|
|
+
|
|
|
+ return drawlistofpolylines(input,layer,thickness)
|
|
|
+
|
|
|
+
|
|
|
+ if not hasattr(input,'__iter__'):
|
|
|
+ raise TypeError('%s expects argument to be a list or string.'%('command'))
|
|
|
+
|
|
|
+
|
|
|
+ if not hasattr(input[0],'__iter__'):
|
|
|
+ return drawlistofpolylines([input],layer,thickness)
|
|
|
+
|
|
|
+ return drawlistofpolylines(input,layer,thickness)
|
|
|
+
|
|
|
+
|
|
|
+ if isinstance(input[0],basestring):
|
|
|
+ temp = []
|
|
|
+ input = map(lambda y: floatnoerror(y),map(lambda x: temp.extend(x),[i.split(',') for i in input]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if not hasattr(input[0],'__iter__') and not isinstance(input[0],pcbnew.wxPoint):
|
|
|
+
|
|
|
+ a = iter(input)
|
|
|
+ input = [izip(a, a)]
|
|
|
+
|
|
|
+ if isinstance(input[0],pcbnew.wxPoint):
|
|
|
+ input = [input]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ drawlistofpolylines(input,layer,thickness)
|
|
|
+
|
|
|
+ allsegments = []
|
|
|
+ segments = []
|
|
|
+ for shape in input:
|
|
|
+
|
|
|
+ if isinstance(shape[0],(float,int)):
|
|
|
+ a = iter(shape)
|
|
|
+ shape = [pcbnew.wxPoint(int(x),int(y)) for x,y in izip(a, a)]
|
|
|
+ for i in range(len(shape)-1):
|
|
|
+ segments.append(draw_segmentwx(
|
|
|
+ shape[i],
|
|
|
+ shape[i+1],
|
|
|
+ layer=layer,
|
|
|
+ thickness=thickness))
|
|
|
+ allsegments.append(segments)
|
|
|
+ segments = []
|
|
|
+ return allsegments
|
|
|
+
|
|
|
+
|
|
|
+def drawlistofpolylines(input_lop,layer,thickness):
|
|
|
+
|
|
|
+ allsegments = []
|
|
|
+ segments = []
|
|
|
+ for shape in input_lop:
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ numbers = shape
|
|
|
+ if isinstance(numbers,basestring):
|
|
|
+ output('string2')
|
|
|
+ numbers = map(lambda x: float(x),shape.split(','))
|
|
|
+
|
|
|
+ if not hasattr(numbers[0],'__getitem__'):
|
|
|
+
|
|
|
+ a=iter(numbers)
|
|
|
+ numbers = [(intnoerror(x),intnoerror(y)) for x,y in izip(a, a)]
|
|
|
+ for i in range(len(numbers)-1):
|
|
|
+ s = numbers[i]
|
|
|
+ e = numbers[i+1]
|
|
|
+
|
|
|
+ if not isinstance(numbers[i],pcbnew.wxPoint) or not isinstance(numbers[i],pcbnew.wxPoint):
|
|
|
+ try:
|
|
|
+ s = pcbnew.wxPoint(numbers[i][0],numbers[i][1])
|
|
|
+ e = pcbnew.wxPoint(numbers[i+1][0],numbers[i+1][1])
|
|
|
+ except:
|
|
|
+ continue
|
|
|
+ segments.append(draw_segmentwx(s,e,layer=layer,thickness=thickness))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ allsegments.append(segments)
|
|
|
+ segments = []
|
|
|
+ return allsegments
|
|
|
+
|
|
|
+
|
|
|
+def close_enough(a,b):
|
|
|
+ return abs(a-b)<(5*32)
|
|
|
+def GRID(dseglist,grid):
|
|
|
+ grid = int(grid)
|
|
|
+ for seg in dseglist:
|
|
|
+ for gp,sp in ((seg.GetStart,seg.SetStart),(seg.GetEnd,seg.SetEnd)):
|
|
|
+ p = gp()
|
|
|
+ newp=pcbnew.wxPoint(int(round(p[0]/grid)*grid),int(round(p[1]/grid)*grid))
|
|
|
+ sp(newp)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def SCALE(dseglist,factor):
|
|
|
+
|
|
|
+ num = 2*len(dseglist)
|
|
|
+ pairs = map(lambda seg: get_ds_ends(seg),dseglist)
|
|
|
+ points = [item for sublist in pairs for item in sublist]
|
|
|
+ xs, ys = itertools.tee(points)
|
|
|
+ xsum, ysum = sum(x[0] for x in xs), sum(y[1] for y in ys)
|
|
|
+ center = pcbnew.wxPoint(xsum/num,ysum/num)
|
|
|
+
|
|
|
+ output('Center: %s'%(center))
|
|
|
+ for seg in dseglist:
|
|
|
+ for gp,sp in ((seg.GetStart,seg.SetStart),(seg.GetEnd,seg.SetEnd)):
|
|
|
+ p = gp()
|
|
|
+ v=p-center
|
|
|
+ newp=wxPointUtil.scale(v,float(factor))+center
|
|
|
+ sp(newp)
|
|
|
+
|
|
|
+def LENGTH(dseglist):
|
|
|
+ return map(lambda seg: wxPointUtil.distance(*get_ds_ends(seg)), dseglist)
|
|
|
+
|
|
|
+def REGULAR(dseglist):
|
|
|
+ """create a regular polygon from the set of connected and closed segments"""
|
|
|
+ ordered = order_segments(dseglist)
|
|
|
+ ordered = ordered[0]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ numsides = len(dseglist)
|
|
|
+
|
|
|
+
|
|
|
+ sidelength = max(map(lambda seg: wxPointUtil.distance(*get_ds_ends(seg)), dseglist))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ polarity = []
|
|
|
+ s,e = get_ds_ends(ordered[0])
|
|
|
+ for i in range(len(ordered)-1):
|
|
|
+ sn,en = get_ds_ends(ordered[(i+1)%len(ordered)])
|
|
|
+ polarity.append((close_enough(e[0],sn[0]) and close_enough(e[1],sn[1])) or
|
|
|
+ (close_enough(e[0],en[0]) and close_enough(e[1],en[1])))
|
|
|
+ e = en
|
|
|
+ polarity.append(polarity[0])
|
|
|
+ angle = 2*math.pi / numsides
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ angleincrement = 2*math.pi/numsides
|
|
|
+ for i in range(len(ordered)-1):
|
|
|
+ if polarity[i]:
|
|
|
+ anchor,free = get_ds_ends(ordered[i])
|
|
|
+ else:
|
|
|
+ free,anchor = get_ds_ends(ordered[i])
|
|
|
+
|
|
|
+ if i == 0:
|
|
|
+ firstanchor = anchor
|
|
|
+ vector = free - anchor
|
|
|
+ startangle = -math.atan2(vector[1],vector[0])
|
|
|
+
|
|
|
+
|
|
|
+ angle = startangle+2*math.pi*i/numsides
|
|
|
+
|
|
|
+ vector = wxPointUtil.towxPoint(sidelength,angle)
|
|
|
+
|
|
|
+ endpoint = anchor+vector
|
|
|
+
|
|
|
+ if polarity[i]:
|
|
|
+ ordered[i].SetEnd(endpoint)
|
|
|
+
|
|
|
+
|
|
|
+ else:
|
|
|
+ ordered[i].SetStart(endpoint)
|
|
|
+
|
|
|
+
|
|
|
+ if polarity[i+1]:
|
|
|
+ ordered[i+1].SetStart(endpoint)
|
|
|
+
|
|
|
+ else:
|
|
|
+ ordered[i+1].SetEnd(endpoint)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def get_ds_ends(dseg):
|
|
|
+ try:
|
|
|
+ shape = dseg.GetShape()
|
|
|
+ except:
|
|
|
+ try:
|
|
|
+ return dseg.GetStart(), dseg.GetEnd()
|
|
|
+ except:
|
|
|
+ try:
|
|
|
+ return dseg[0],dseg[1]
|
|
|
+ except:
|
|
|
+
|
|
|
+ output ('error get get_ds_ends')
|
|
|
+ return
|
|
|
+ if shape == pcbnew.S_SEGMENT:
|
|
|
+ return dseg.GetStart(), dseg.GetEnd()
|
|
|
+ elif shape == pcbnew.S_ARC:
|
|
|
+
|
|
|
+ start = dseg.GetArcStart()
|
|
|
+ center = dseg.GetCenter()
|
|
|
+ angle = dseg.GetAngle()/10.0
|
|
|
+ radians = angle*math.pi/180
|
|
|
+ radians = dseg.GetAngle() * math.pi / 1800
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ CS = start-center
|
|
|
+ CE = wxPointUtil.rotatexy(CS,radians)
|
|
|
+
|
|
|
+ end = CE + center
|
|
|
+ return start, end
|
|
|
+
|
|
|
+ elif shape == pcbnew.S_CURVE:
|
|
|
+ output ('Warning: KiCommand cannot determine S_CURVE end points. Skipping.')
|
|
|
+ else:
|
|
|
+ output('Warning: There are no endpoints to %s'%dseg.GetShapeStr())
|
|
|
+ return None
|
|
|
+
|
|
|
+ return dseg.GetStart(), dseg.GetEnd()
|
|
|
+def get_drawsegment_points(dseglist):
|
|
|
+ return dseg.GetStart(), dseg.GetEnd()
|
|
|
+def CONNECT(dseglist):
|
|
|
+ """given a list of almost-connected DRAWSEGMENTs, move their endpoints such that they are coincident. It is assumed
|
|
|
+ that each segment connects to two others, except perhaps the 'end' segments."""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ points = defaultdict(set)
|
|
|
+
|
|
|
+ for dseg in dseglist:
|
|
|
+ s,e = get_ds_ends(dseg)
|
|
|
+ s = point_round128(s)
|
|
|
+ e = point_round128(e)
|
|
|
+ st = (s[0],s[1])
|
|
|
+ et = (e[0],e[1])
|
|
|
+ points[st].add(dseg)
|
|
|
+ points[et].add(dseg)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ unconnected=filter(lambda x: len(points[x]) == 1, points.keys())
|
|
|
+
|
|
|
+
|
|
|
+ distances2 = defaultdict(list)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for i,p in enumerate(unconnected):
|
|
|
+ distances2[p] = \
|
|
|
+ [(unconnected[j],wxPointUtil.distance2(unconnected[i],unconnected[j])) for j in range(0,len(unconnected)) if i!=j]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for distanceslist in distances2.values():
|
|
|
+ distanceslist.sort(key=lambda dist:dist[1])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ pointset = set(points.keys())
|
|
|
+
|
|
|
+ for point in unconnected:
|
|
|
+
|
|
|
+
|
|
|
+ if point not in pointset:
|
|
|
+ continue
|
|
|
+
|
|
|
+
|
|
|
+ point2 = distances2[point][0][0]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if point == distances2[point2][0][0]:
|
|
|
+ newpoint = point
|
|
|
+ for pchange,newpoint in ((point,point2),(point2,point)):
|
|
|
+ try: pointset.remove(pchange)
|
|
|
+ except: pass
|
|
|
+ try: pointset.remove(newpoint)
|
|
|
+ except: pass
|
|
|
+
|
|
|
+ (seg,) = points[pchange]
|
|
|
+ if seg.GetShapeStr() != 'Line':
|
|
|
+ continue
|
|
|
+ segstart,segend = get_ds_ends(seg)
|
|
|
+ segstart = point_round128(segstart)
|
|
|
+ segend = point_round128(segend)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if segstart[0] == pchange[0] and segstart[1] == pchange[1]:
|
|
|
+
|
|
|
+ seg.SetStart(pcbnew.wxPoint(newpoint[0],newpoint[1]))
|
|
|
+
|
|
|
+ elif segend[0] == pchange[0] and segend[1] == pchange[1]:
|
|
|
+
|
|
|
+ seg.SetEnd(pcbnew.wxPoint(newpoint[0],newpoint[1]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ break
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def is_connected(w,v):
|
|
|
+ return wxPointUtil.distance2(w,v) < 200*200
|
|
|
+
|
|
|
+def order_segments(dseglist):
|
|
|
+
|
|
|
+ segs_by_box = defaultdict(set)
|
|
|
+ boxes_by_seg = {}
|
|
|
+
|
|
|
+ for seg in dseglist:
|
|
|
+ s,e = get_ds_ends(seg)
|
|
|
+ gbs = gridboxes(s)
|
|
|
+ gbe = gridboxes(e)
|
|
|
+
|
|
|
+ sdict={}
|
|
|
+ for b in gbs:
|
|
|
+ sdict[b] = e
|
|
|
+
|
|
|
+ segs_by_box[b].add(seg)
|
|
|
+ edict={}
|
|
|
+ for b in gbe:
|
|
|
+
|
|
|
+ edict[b] = s
|
|
|
+ segs_by_box[b].add(seg)
|
|
|
+
|
|
|
+ boxes_by_seg[seg] = {s:sdict,e:edict}
|
|
|
+ """bbs is a structure that you can look up all the boxes the
|
|
|
+ opposing point of the segment exists in."""
|
|
|
+
|
|
|
+ for box,segs in segs_by_box.iteritems():
|
|
|
+ seglist=list(segs)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ connected = defaultdict(set)
|
|
|
+ for b,seglist in segs_by_box.iteritems():
|
|
|
+ for seg1 in seglist:
|
|
|
+ for seg2 in seglist:
|
|
|
+ if seg1 != seg2:
|
|
|
+
|
|
|
+ connected[seg1].add(seg2)
|
|
|
+ connected[seg2].add(seg1)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for seg,seglist in connected.iteritems():
|
|
|
+ if len(seglist) > 2:
|
|
|
+
|
|
|
+ output('Error: segment connected to more than 2 other segments: %s'%
|
|
|
+ str(get_ds_ends(seg)))
|
|
|
+ return dseglist
|
|
|
+
|
|
|
+ segset = set()
|
|
|
+ ordered_and_split = [[]]
|
|
|
+ for seg in dseglist:
|
|
|
+ currentseg = seg
|
|
|
+ lastseg = seg
|
|
|
+ while currentseg is not None and currentseg not in segset:
|
|
|
+ segset.add(currentseg)
|
|
|
+ csegs = list(connected.get(currentseg,None))
|
|
|
+
|
|
|
+ if lastseg in csegs:
|
|
|
+ csegs.remove(lastseg)
|
|
|
+
|
|
|
+ ordered_and_split[-1].append(currentseg)
|
|
|
+ lc = len(csegs)
|
|
|
+ if lc == 0:
|
|
|
+ ordered_and_split.append([])
|
|
|
+ currentseg = None
|
|
|
+ elif lc == 1:
|
|
|
+ lastseg = currentseg
|
|
|
+ currentseg = csegs[0]
|
|
|
+ else:
|
|
|
+ output('Error: segment connected to more than 2 other segments: %s'%
|
|
|
+ str(get_ds_ends(currentseg)))
|
|
|
+ if not ordered_and_split[-1]:
|
|
|
+ ordered_and_split.pop()
|
|
|
+ return ordered_and_split
|
|
|
+
|
|
|
+
|
|
|
+def order_segments_old(dseglist):
|
|
|
+
|
|
|
+
|
|
|
+ segs_by_point = defaultdict(set)
|
|
|
+ points_by_seg = {}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for seg in dseglist:
|
|
|
+ s,e = get_ds_ends(seg)
|
|
|
+ s = point_round128(s)
|
|
|
+ e = point_round128(e)
|
|
|
+ st=(s[0],s[1])
|
|
|
+ et=(e[0],e[1])
|
|
|
+ points_by_seg[seg] = {st:et,et:st}
|
|
|
+
|
|
|
+
|
|
|
+ s,e = get_ds_ends(seg)
|
|
|
+ for p in s,e:
|
|
|
+ p = point_round128(p)
|
|
|
+ segs_by_point[(p[0],p[1])].add(seg)
|
|
|
+
|
|
|
+ if not len(points_by_seg):
|
|
|
+ return
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for currentpoint,seglist in segs_by_point.iteritems():
|
|
|
+ if len(seglist)==1:
|
|
|
+ break
|
|
|
+ ordered = []
|
|
|
+
|
|
|
+ while segs_by_point[currentpoint]:
|
|
|
+ output( "currentpoint = ",currentpoint)
|
|
|
+ currentseg = list(segs_by_point[currentpoint])[0]
|
|
|
+
|
|
|
+
|
|
|
+ ordered.append(currentseg)
|
|
|
+
|
|
|
+ currentpoint = points_by_seg[currentseg][currentpoint]
|
|
|
+ segs = segs_by_point.get(currentpoint,None)
|
|
|
+ if not segs:
|
|
|
+ break
|
|
|
+ try:
|
|
|
+ segs.remove(currentseg)
|
|
|
+ except:
|
|
|
+ break
|
|
|
+ return ordered
|
|
|
+
|
|
|
+def MAKEANGLE(dseglist,degrees):
|
|
|
+ output('makeangle not implemented.')
|
|
|
+ return dseglist
|
|
|
+
|
|
|
+def draw_arc_to_segments(radius,dseglist):
|
|
|
+
|
|
|
+
|
|
|
+ orderedlol = order_segments(dseglist)
|
|
|
+
|
|
|
+ for ordered in orderedlol:
|
|
|
+ for i in range(len(ordered)-1):
|
|
|
+ draw_arc_to_lines(radius[0],ordered[i],ordered[i+1])
|
|
|
+def ANGLE(dseglist):
|
|
|
+ angles = []
|
|
|
+ for seg in dseglist:
|
|
|
+ s,e = get_ds_ends(seg)
|
|
|
+ v=e-s
|
|
|
+ angles.append( -math.atan2(v[1],v[0]) * 180/math.pi )
|
|
|
+
|
|
|
+ return angles
|
|
|
+
|
|
|
+def ROTATE(dseglist,angle):
|
|
|
+ angle = float(angle)
|
|
|
+ allpoints = []
|
|
|
+ for seg in dseglist:
|
|
|
+ allpoints.extend(get_ds_ends(seg))
|
|
|
+ xcenter = 0
|
|
|
+ ycenter = 0
|
|
|
+ for p in allpoints:
|
|
|
+ xcenter += p[0]
|
|
|
+ ycenter += p[1]
|
|
|
+ n = len(allpoints)
|
|
|
+ center = pcbnew.wxPoint(xcenter / n, ycenter / n)
|
|
|
+ for seg in dseglist:
|
|
|
+ shape = seg.GetShape()
|
|
|
+ if shape == pcbnew.S_SEGMENT:
|
|
|
+ seg.SetStart(pcbnew.wxPoint(*rotate_point(seg.GetStart(),center,angle,ccw=True)))
|
|
|
+ seg.SetEnd(pcbnew.wxPoint(*rotate_point(seg.GetEnd(),center,angle,ccw=True)))
|
|
|
+ if shape == pcbnew.S_ARC:
|
|
|
+ seg.SetCenter(pcbnew.wxPoint(*rotate_point(seg.GetCenter(),center,angle,ccw=True)))
|
|
|
+ if shape == pcbnew.S_CIRCLE:
|
|
|
+ seg.SetCenter(pcbnew.wxPoint(*rotate_point(seg.GetCenter(),center,angle,ccw=True)))
|
|
|
+
|
|
|
+def lines_intersect(p,q,w,v):
|
|
|
+
|
|
|
+
|
|
|
+ r=w-p
|
|
|
+ s=v-q
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ drs = wxPointUtil.dot_other(r,s)
|
|
|
+
|
|
|
+ qmp = q-p
|
|
|
+ t = wxPointUtil.dot_other(qmp,s)/ float(drs)
|
|
|
+ u = wxPointUtil.dot_other(qmp,r)/ float(drs)
|
|
|
+
|
|
|
+ intersection = p+wxPointUtil.scale(r,t)
|
|
|
+ i2 = q + wxPointUtil.scale(s,u)
|
|
|
+
|
|
|
+ x1=p[0]
|
|
|
+ y1=p[1]
|
|
|
+ x2=q[0]
|
|
|
+ y2=q[1]
|
|
|
+ x3=w[0]
|
|
|
+ y3=w[1]
|
|
|
+ x4=v[0]
|
|
|
+ y4=v[1]
|
|
|
+ x2112 = (x2*y1-x1*y2)
|
|
|
+ x4334 = (x4*y3-x3*y4)
|
|
|
+
|
|
|
+ divisor = (x2-x1)*(y4-y3)-(x4-x3)*(y2-y1)
|
|
|
+ if divisor == 0:
|
|
|
+ return None
|
|
|
+ xi = (x2112*(x4-x3) - x4334*(x2-x1))/divisor
|
|
|
+ yi = (x2112*(y4-y3) - x4334*(y2-y1)) / divisor
|
|
|
+
|
|
|
+
|
|
|
+ return pcbnew.wxPoint(xi,yi)
|
|
|
+
|
|
|
+
|
|
|
+def draw_arc_to_lines(radius,pqseg,wvseg):
|
|
|
+ p=pqseg.GetStart()
|
|
|
+ q=pqseg.GetEnd()
|
|
|
+ w=wvseg.GetStart()
|
|
|
+ v=wvseg.GetEnd()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ intersection = None
|
|
|
+ if p==w or p==v:
|
|
|
+ intersection = pcbnew.wxPoint(p[0],p[1])
|
|
|
+ if q==w or q==v:
|
|
|
+ intersection = pcbnew.wxPoint(q[0],q[1])
|
|
|
+
|
|
|
+ if intersection is None:
|
|
|
+ intersection = lines_intersect(p,q,w,v)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ dp = wxPointUtil.distance2(intersection,p)
|
|
|
+ dq = wxPointUtil.distance2(intersection,q)
|
|
|
+ dw = wxPointUtil.distance2(intersection,w)
|
|
|
+ dv = wxPointUtil.distance2(intersection,v)
|
|
|
+
|
|
|
+
|
|
|
+ wvswapped = False
|
|
|
+ if dw<dv:
|
|
|
+ wv = (w,v)
|
|
|
+ else:
|
|
|
+ wv = (v,w)
|
|
|
+ wvswapped = True
|
|
|
+ pq,pqswapped = ((p,q),False) if dp<dq else ((q,p),True)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ vi = wv[1]-intersection
|
|
|
+ qi = pq[1]-intersection
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ awv = -math.atan2(vi[1],vi[0])
|
|
|
+ apq = -math.atan2(qi[1],qi[0])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if 0 > (awv-apq):
|
|
|
+
|
|
|
+ theta = (apq - awv)%(2*math.pi)
|
|
|
+ bigger='p'
|
|
|
+ fromnorm = wv[1]
|
|
|
+ else:
|
|
|
+
|
|
|
+ theta = (awv - apq)%(2*math.pi)
|
|
|
+ fromnorm = pq[1]
|
|
|
+ bigger='w'
|
|
|
+
|
|
|
+ theta = (apq - awv)%(2*math.pi)
|
|
|
+ bigger='p'
|
|
|
+ fromnorm = wv[1]
|
|
|
+
|
|
|
+ norm = wxPointUtil.normal(fromnorm-intersection)
|
|
|
+ norm = wxPointUtil.scale(norm,radius/wxPointUtil.mag(norm))
|
|
|
+ arcangle = ((math.pi + theta)%(2*math.pi))*180/math.pi
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ distance_intersection_to_tangent = abs(radius/math.tan(theta/2.0))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ wvtpoint = intersection + wxPointUtil.scale(wv[1]-intersection,distance_intersection_to_tangent/wxPointUtil.distance(intersection,wv[1]))
|
|
|
+ pqtpoint = intersection + wxPointUtil.scale(pq[1]-intersection,distance_intersection_to_tangent/wxPointUtil.distance(intersection,pq[1]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ arcstart = wvtpoint if bigger=='w' else pqtpoint
|
|
|
+ center = wvtpoint if bigger=='p' else pqtpoint
|
|
|
+ center = center + norm
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ thickness = int((pqseg.GetWidth()+wvseg.GetWidth())/2.0)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if theta%(2*math.pi) > math.pi:
|
|
|
+ p,start = (wvtpoint,pqtpoint)
|
|
|
+ else:
|
|
|
+ p,start = (pqtpoint,wvtpoint)
|
|
|
+ theta = -theta
|
|
|
+
|
|
|
+ n = wxPointUtil.normal(p-intersection)
|
|
|
+ n = wxPointUtil.scale(n,radius/wxPointUtil.mag(n))
|
|
|
+ c = p+n
|
|
|
+ arcangle = ((math.pi + theta)%(2*math.pi))*180/math.pi
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ draw_arc(start[0],start[1],c[0],c[1],arcangle,layer=pqseg.GetLayer(),thickness=thickness)
|
|
|
+
|
|
|
+
|
|
|
+ if wvswapped:
|
|
|
+ wvseg.SetEnd(wvtpoint)
|
|
|
+ else:
|
|
|
+ wvseg.SetStart(wvtpoint)
|
|
|
+ if pqswapped:
|
|
|
+ pqseg.SetEnd(pqtpoint)
|
|
|
+ else:
|
|
|
+ pqseg.SetStart(pqtpoint)
|
|
|
+
|
|
|
+ return
|
|
|
+
|
|
|
+ angle = ((awv-apq)*180/math.pi)
|
|
|
+ if -math.pi < theta*2 < math.pi:
|
|
|
+ leftfirst = (pq,wv)
|
|
|
+ anglebase = awv
|
|
|
+ tangentfirst = (pqtpoint,wvtpoint)
|
|
|
+ else:
|
|
|
+ leftfirst = (wv,pq)
|
|
|
+ anglebase = apq
|
|
|
+ tangentfirst = (wvtpoint,pqtpoint)
|
|
|
+ angle = -angle
|
|
|
+
|
|
|
+ sign = (theta % 2*math.pi) - math.pi
|
|
|
+ sign = sign/abs(sign)
|
|
|
+ sign = 1
|
|
|
+
|
|
|
+
|
|
|
+ lf01 = leftfirst[0][1]
|
|
|
+ lf11 = leftfirst[1][1]
|
|
|
+ centerlinepoint = wxPointUtil.scale(lf01-intersection,wxPointUtil.mag(lf11)/wxPointUtil.mag(lf01)) + lf11
|
|
|
+
|
|
|
+ rotatevector = lambda v,a: pcbnew.wxPoint(v[0]*math.cos(a)-v[1]*math.sin(a),v[0]*math.sin(a)+v[1]*math.cos(a))
|
|
|
+
|
|
|
+ centerlinepoint = rotatevector(lf01-intersection,math.pi-apq)+intersection
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ centervector = centerlinepoint - intersection
|
|
|
+ cangle = -math.atan2(centervector[1],centervector[0])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ arcstart = tangentfirst[1]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ wvtpi = wvtpoint-intersection
|
|
|
+ pqtpi = pqtpoint-intersection
|
|
|
+
|
|
|
+ lefttpi = arcstart-intersection
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ center = arcstart+wxPointUtil.scale(pcbnew.wxPoint(lefttpi[1],-lefttpi[0]),sign*radius/
|
|
|
+ math.sqrt(lefttpi[0]*lefttpi[0]+lefttpi[1]*lefttpi[1]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ center2 = wvtpoint+wxPointUtil.scale(pcbnew.wxPoint(-wvtpi[1],wvtpi[0]),radius/
|
|
|
+ math.sqrt(wvtpi[0]*wvtpi[0]+wvtpi[1]*wvtpi[1]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ ci = center - intersection
|
|
|
+ acenter = -math.atan2(ci[1],ci[0])
|
|
|
+
|
|
|
+
|
|
|
+ pqtpi = pqtpoint-intersection
|
|
|
+
|
|
|
+ center3 = pqtpoint+wxPointUtil.scale(wxPointUtil.normal(pqtpi),radius/
|
|
|
+ math.sqrt(pqtpi[0]*pqtpi[0]+pqtpi[1]*pqtpi[1]))
|
|
|
+
|
|
|
+
|
|
|
+ center4 = pqtpoint+wxPointUtil.scale(pcbnew.wxPoint(pqtpi[1],-pqtpi[0]),radius/
|
|
|
+ math.sqrt(pqtpi[0]*pqtpi[0]+pqtpi[1]*pqtpi[1]))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ thickness = int((pqseg.GetWidth()+wvseg.GetWidth())/2.0)
|
|
|
+
|
|
|
+ draw_arc(arcstart[0],arcstart[1],center[0],center[1],angle,layer=pqseg.GetLayer(),thickness=thickness)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def draw_arc(x1,y1,x2,y2,angle,layer=pcbnew.Dwgs_User,thickness=0.15*pcbnew.IU_PER_MM):
|
|
|
+ """Point 1 is start, point 2 is center. Draws the arc indicated by the x,y values
|
|
|
+ on the given layer and with the given thickness."""
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ ds=pcbnew.DRAWSEGMENT(board)
|
|
|
+ ds.SetShape(pcbnew.S_ARC)
|
|
|
+ ds.SetLayer(layer)
|
|
|
+ ds.SetWidth(max(1,int(thickness)))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ ds.SetArcStart(pcbnew.wxPoint(x1,y1))
|
|
|
+ ds.SetAngle(float(angle)*10)
|
|
|
+ ds.SetCenter(pcbnew.wxPoint(x2,y2))
|
|
|
+
|
|
|
+ board.Add(ds)
|
|
|
+ return ds
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def draw_segment(x1,y1,x2,y2,layer=pcbnew.Dwgs_User,thickness=0.15*pcbnew.IU_PER_MM):
|
|
|
+ """Draws the line segment indicated by the x,y values
|
|
|
+ on the given layer and with the given thickness."""
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ ds=pcbnew.DRAWSEGMENT(board)
|
|
|
+ board.Add(ds)
|
|
|
+ ds.SetStart(pcbnew.wxPoint(x1,y1))
|
|
|
+ ds.SetEnd(pcbnew.wxPoint(x2,y2))
|
|
|
+ ds.SetLayer(layer)
|
|
|
+ ds.SetWidth(max(1,int(thickness)))
|
|
|
+ return ds
|
|
|
+
|
|
|
+def draw_segmentwx(startwxpoint,endwxpoint,layer=pcbnew.Dwgs_User,thickness=0.15*pcbnew.IU_PER_MM):
|
|
|
+ """Draws the line segment indicated by the x,y values
|
|
|
+ on the given layer and with the given thickness."""
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ if pcbnew.IsCopperLayer(layer):
|
|
|
+ ds=pcbnew.TRACK(board)
|
|
|
+ else:
|
|
|
+ ds=pcbnew.DRAWSEGMENT(board)
|
|
|
+ board.Add(ds)
|
|
|
+
|
|
|
+ ds.SetStart(startwxpoint)
|
|
|
+ ds.SetEnd(endwxpoint)
|
|
|
+ ds.SetLayer(layer)
|
|
|
+ ds.SetWidth(max(1,int(thickness)))
|
|
|
+ return ds
|
|
|
+
|
|
|
+def layer(layer):
|
|
|
+ try:
|
|
|
+ return int(layer)
|
|
|
+ except:
|
|
|
+ return _user_stacks['Board'][-1].GetLayerID(layer)
|
|
|
+
|
|
|
+def draw_text(text,pos,size,layer=pcbnew.Dwgs_User,thickness=0.15*pcbnew.IU_PER_MM):
|
|
|
+ """Draws the line segment indicated by the x,y values
|
|
|
+ on the given layer and with the given thickness."""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ size = pcbnew.wxSize(size[0],size[1])
|
|
|
+ pos = pcbnew.wxPoint(pos[0],pos[1])
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ thickness = int(thickness)
|
|
|
+ try:
|
|
|
+ layer = int(layer)
|
|
|
+ except:
|
|
|
+ layer = board.GetLayerID(layer)
|
|
|
+
|
|
|
+
|
|
|
+ ds=pcbnew.TEXTE_PCB(board)
|
|
|
+ board.Add(ds)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ ds.SetPosition(pos)
|
|
|
+ ds.SetTextAngle(0.0)
|
|
|
+ ds.SetText(text)
|
|
|
+ ds.SetThickness(thickness)
|
|
|
+ ds.SetTextSize(size)
|
|
|
+ ds.SetLayer(layer)
|
|
|
+ return ds
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def CALLLIST(modulelist,function):
|
|
|
+ """works with function 'Pads' or 'GraphicalItems'"""
|
|
|
+ items = []
|
|
|
+ for m in modulelist:
|
|
|
+ items.extend(getattr(m,function)())
|
|
|
+ return items
|
|
|
+
|
|
|
+def gridboxes(w,getdict=None,setdict=None,setelement=None):
|
|
|
+ """returns a set of grid boxes (upper left corners) that
|
|
|
+ correspond to point w
|
|
|
+ if getdict is set, then gridboxes is used to retreive its elements
|
|
|
+ if setdict is set, then gridboxes is used to set its elements"""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ round_bits = 5
|
|
|
+ increment = 1 << round_bits
|
|
|
+ mask = -1 << round_bits
|
|
|
+
|
|
|
+ c1 = w[0] & mask
|
|
|
+ r1 = w[1] & mask
|
|
|
+ r0 = r1 - increment
|
|
|
+ c0 = c1 - increment
|
|
|
+
|
|
|
+
|
|
|
+ boxes = ((c0,r0),(c0,r1),(c1,r0),(c1,r1))
|
|
|
+ if getdict is not None:
|
|
|
+ seglist = []
|
|
|
+ map(lambda x: seglist.extend(getdict[x]),boxes)
|
|
|
+
|
|
|
+ return seglist
|
|
|
+ if setdict is not None:
|
|
|
+ map(lambda x: setdict[x].append(setelement),boxes)
|
|
|
+ return None
|
|
|
+
|
|
|
+ return boxes
|
|
|
+
|
|
|
+def point_round128(w):
|
|
|
+ mask = -1 << 5
|
|
|
+
|
|
|
+ return w.__class__(int(w[0])&mask,int(w[1])&mask)
|
|
|
+
|
|
|
+
|
|
|
+def newzone(points, netname, layer, CPolyLine=pcbnew.CPolyLine.NO_HATCH, priority=0):
|
|
|
+ """NOT IMPLEMENTED"""
|
|
|
+
|
|
|
+
|
|
|
+ priority = int(priority)
|
|
|
+
|
|
|
+ if isinstance(CPolyLine,basestring):
|
|
|
+ CPolyLine = getattr(pcbnew.CPolyLine,CPolyLine)
|
|
|
+
|
|
|
+ try:
|
|
|
+ layer = int(layer)
|
|
|
+ except:
|
|
|
+ layer = board.GetLayerID(layer)
|
|
|
+
|
|
|
+
|
|
|
+ nets = board.GetNetsByName()
|
|
|
+
|
|
|
+
|
|
|
+ netinfo = nets.find(netname).value()[1]
|
|
|
+
|
|
|
+ newarea = board.InsertArea(netinfo.GetNet(), priority, layer, points[0][0], points[0][1], CPolyLine)
|
|
|
+ newoutline = newarea.Outline()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for p in range(1,len(points)):
|
|
|
+ newoutline.Append(points[p][0],points[p][1]);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if CPolyLine != pcbnew.CPolyLine.NO_HATCH:
|
|
|
+ newarea.Hatch()
|
|
|
+
|
|
|
+def SETLENGTH(initlist, length):
|
|
|
+ """NOT IMPLEMENTED"""
|
|
|
+
|
|
|
+ allitems = list(_user_stacks['Board'][-1].GetDrawings())
|
|
|
+ for m in _user_stacks['Board'][-1].GetModules():
|
|
|
+ allitems.extend(m.GraphicalItems())
|
|
|
+ wholelist = filter(lambda x: isinstance(x,pcbnew.DRAWSEGMENT),allitems)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ se = map(lambda x: get_ds_ends(x),wholelist)
|
|
|
+ d = defaultdict(list)
|
|
|
+
|
|
|
+
|
|
|
+ for i,item in enumerate(wholelist):
|
|
|
+ gridboxes(se[i][0],setdict=d,setelement=item)
|
|
|
+ gridboxes(se[i][1],setdict=d,setelement=item)
|
|
|
+ i = 0
|
|
|
+ retValue = list(initlist)
|
|
|
+ retValueSet = set()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ while i < len(retValue):
|
|
|
+ if i > 1000:
|
|
|
+ break
|
|
|
+
|
|
|
+ se = get_ds_ends(retValue[i])
|
|
|
+
|
|
|
+
|
|
|
+ try: d[key].remove(retValue[i])
|
|
|
+ except: pass
|
|
|
+ retValue.extend(gridboxes(se[0],getdict=d))
|
|
|
+ try: d[key].remove(retValue[i])
|
|
|
+ except: pass
|
|
|
+ newset = set(gridboxes(se[1],getdict=d))
|
|
|
+
|
|
|
+ for member in newset:
|
|
|
+ if member not in retValueSet:
|
|
|
+ retValueSet.add(member)
|
|
|
+ i += 1
|
|
|
+ return list(set(retValue))
|
|
|
+
|
|
|
+def CONNECTED(wholelist, initlist):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ se = map(lambda x: get_ds_ends(x),wholelist)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ d = defaultdict(list)
|
|
|
+
|
|
|
+ for i,item in enumerate(wholelist):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ gridboxes(se[i][0],setdict=d,setelement=item)
|
|
|
+ gridboxes(se[i][1],setdict=d,setelement=item)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ i = 0
|
|
|
+ retValue = list(initlist)
|
|
|
+ retValueSet = set()
|
|
|
+
|
|
|
+
|
|
|
+ while i < len(retValue):
|
|
|
+ if i > 1000:
|
|
|
+ break
|
|
|
+
|
|
|
+ se = get_ds_ends(retValue[i])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ try: d[key].remove(retValue[i])
|
|
|
+ except: pass
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ retValue.extend(gridboxes(se[0],getdict=d))
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ try: d[key].remove(retValue[i])
|
|
|
+ except: pass
|
|
|
+
|
|
|
+ newset = set(gridboxes(se[1],getdict=d))
|
|
|
+
|
|
|
+ for member in newset:
|
|
|
+ if member not in retValueSet:
|
|
|
+
|
|
|
+
|
|
|
+ retValueSet.add(member)
|
|
|
+ i += 1
|
|
|
+
|
|
|
+ return list(set(retValue))
|
|
|
+
|
|
|
+def bbintersect(seg1,seg2):
|
|
|
+ s1bb = seg1.GetBoundingBox()
|
|
|
+ s2bb = seg2.GetBoundingBox()
|
|
|
+ return True
|
|
|
+
|
|
|
+def CUT():
|
|
|
+
|
|
|
+ cutees = filter(
|
|
|
+ lambda x: isinstance(x,pcbnew.DRAWSEGMENT) and x.GetShape() == pcbnew.S_SEGMENT,
|
|
|
+ _user_stacks['Board'][-1].GetDrawings())
|
|
|
+
|
|
|
+ cutter = filter(lambda x:x.IsSelected(),cutees)[0]
|
|
|
+ scutter,ecutter = get_ds_ends(cutter)
|
|
|
+
|
|
|
+ bb = cutter.GetBoundingBox()
|
|
|
+ cutl,cutr,cutt,cutb = bb.GetLeft(),bb.GetRight(),bb.GetTop(),bb.GetBottom()
|
|
|
+ within = []
|
|
|
+ for cutee in cutees:
|
|
|
+ if cutee == cutter:
|
|
|
+
|
|
|
+ continue
|
|
|
+ if not isinstance(cutee,pcbnew.DRAWSEGMENT):
|
|
|
+ continue
|
|
|
+ if cutee.GetShape() != pcbnew.S_SEGMENT:
|
|
|
+ continue
|
|
|
+
|
|
|
+ bb = cutee.GetBoundingBox()
|
|
|
+ segl,segr,segt,segb = bb.GetLeft(),bb.GetRight(),bb.GetTop(),bb.GetBottom()
|
|
|
+ if segr < cutl or segl > cutr or segb < cutt or segt > cutb:
|
|
|
+ continue
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ s,e = get_ds_ends(cutee)
|
|
|
+ intersect = lines_intersect(s,e,scutter,ecutter)
|
|
|
+
|
|
|
+ if intersect is None:
|
|
|
+ output('intersect returned None')
|
|
|
+ continue
|
|
|
+
|
|
|
+ if ((s[0] < intersect[0] < e[0]) or (e[0] < intersect[0] < s[0])) and \
|
|
|
+ ((s[1] < intersect[1] < e[1]) or (e[1] < intersect[1] < s[1])) and \
|
|
|
+ ((scutter[0] < intersect[0] < ecutter[0]) or (ecutter[0] < intersect[0] < scutter[0])) and \
|
|
|
+ ((scutter[1] < intersect[1] < ecutter[1]) or (ecutter[1] < intersect[1] < scutter[1])):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ newe = tuple(e)
|
|
|
+ cutee.SetEnd(intersect)
|
|
|
+ draw_segment(intersect[0],intersect[1],newe[0],newe[1],layer=cutee.GetLayer(),thickness=cutee.GetWidth())
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ _user_stacks['Board'][-1].GetDrawings().Remove(cutter)
|
|
|
+
|
|
|
+ return None
|
|
|
+def DRAWPARAMS(dims,layer):
|
|
|
+ t,w,h = dims.split(',') if isinstance(dims,basestring) else dims \
|
|
|
+ if hasattr(dims,'__iter__') else [dims]
|
|
|
+
|
|
|
+ try:
|
|
|
+ layerID = int(layer)
|
|
|
+ except:
|
|
|
+ layerID = _user_stacks['Board'][-1].GetLayerID(str(layer))
|
|
|
+
|
|
|
+ _user_stacks['drawparams'] = [t,w,h,layerID]
|
|
|
+
|
|
|
+def list_to_paired_list(input):
|
|
|
+ a = iter(input)
|
|
|
+ input = [pcbnew.wxPoint(int(x),int(y)) for x,y in izip(a, a)]
|
|
|
+ return input
|
|
|
+
|
|
|
+def convert_to_points(input):
|
|
|
+
|
|
|
+ if isinstance(input,basestring):
|
|
|
+ input = map(lambda x: float(x),input.split(','))
|
|
|
+
|
|
|
+ if (not hasattr(input,'__iter__')) :
|
|
|
+ input=[input]
|
|
|
+
|
|
|
+ if hasattr(input,'__getitem__') and not hasattr(input[0],'__iter__'):
|
|
|
+ input=[input]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ input = [list_to_paired_list(i) if isinstance(i[0],(basestring,float,int)) else i for i in input]
|
|
|
+
|
|
|
+ return input
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def FINDNET(netname):
|
|
|
+
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ netinfo = board.FindNet(netname)
|
|
|
+ return netinfo.GetNet()
|
|
|
+
|
|
|
+
|
|
|
+class commands:
|
|
|
+ classinstance = None
|
|
|
+ def NEWNET(self,netname):
|
|
|
+ """Create a new net with name netname."""
|
|
|
+
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+
|
|
|
+
|
|
|
+ netinfo = pcbnew.NETINFO_ITEM(board, netname)
|
|
|
+
|
|
|
+
|
|
|
+ board.AppendNet(netinfo)
|
|
|
+
|
|
|
+
|
|
|
+ return netinfo.GetNet()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ NEWNET.nargs = 1
|
|
|
+ NEWNET.category = 'Draw'
|
|
|
+
|
|
|
+ def getpads(self,items):
|
|
|
+ """[MODULES] Get pads of each module in MODULES."""
|
|
|
+ items = items[0]
|
|
|
+ p = []
|
|
|
+ for i in items:
|
|
|
+ p.extend(list(i.Pads()))
|
|
|
+ return p
|
|
|
+ getpads.nargs = 1
|
|
|
+ getpads.category = 'Elements'
|
|
|
+
|
|
|
+ def select(self,items):
|
|
|
+ '[objects] Select the objects'
|
|
|
+ filter(lambda x: x.SetSelected(), items[0])
|
|
|
+ select.nargs = 1
|
|
|
+ select.category = 'Action'
|
|
|
+
|
|
|
+ def deselect(self,items):
|
|
|
+ '[objects] Deselect the objects'
|
|
|
+ filter(lambda x: x.ClearSelected(), items[0])
|
|
|
+ deselect.nargs = 1
|
|
|
+ deselect.category = 'Action'
|
|
|
+
|
|
|
+ def pads(self,empty):
|
|
|
+ """Get all pads"""
|
|
|
+ p=[]
|
|
|
+ for m in _user_stacks['Board'][-1].GetModules():
|
|
|
+ p.extend(list(m.Pads()))
|
|
|
+ return p
|
|
|
+ pads.nargs = 0
|
|
|
+ pads.category = 'Elements'
|
|
|
+
|
|
|
+ def AREAS(self,empty):
|
|
|
+ """Return all Areas of the board (includes Zones and Keepouts)."""
|
|
|
+ b = _user_stacks['Board'][-1]
|
|
|
+ return [b.GetArea(i) for i in range(b.GetAreaCount())]
|
|
|
+
|
|
|
+ AREAS.nargs = 0
|
|
|
+ AREAS.category = 'Elements,Area'
|
|
|
+
|
|
|
+ def ZONES(self,ignore):
|
|
|
+ """Return all Zones of the board."""
|
|
|
+ b = _user_stacks['Board'][-1]
|
|
|
+ return filter(lambda c: not c.IsKeepout(),[b.GetArea(i) for i in range(b.GetAreaCount())])
|
|
|
+ ZONES.nargs = 0
|
|
|
+ ZONES.category = 'Elements,Area'
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ def TOPOINTS(self,itemlist):
|
|
|
+ """[EDA_TEXTLIST] a list of EDA_TEXT items, which are converted to point pairs suitable for TODRAWSEGMENTS"""
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ strokes = []
|
|
|
+
|
|
|
+ for t in itemlist[0]:
|
|
|
+
|
|
|
+ strokes.append(pcbnew.wxPoint_Vector(0))
|
|
|
+ t.TransformTextShapeToSegmentList(strokes[-1])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if isinstance(t,pcbnew.TEXTE_MODULE):
|
|
|
+ orientation = t.GetDrawRotation()\
|
|
|
+ -t.GetTextAngle()
|
|
|
+
|
|
|
+
|
|
|
+ strokes[-1] = self.get_rotated_vector(strokes[-1],t.GetCenter(),orientation)
|
|
|
+ return strokes
|
|
|
+ TOPOINTS.nargs = 1
|
|
|
+ TOPOINTS.category = 'Draw,Geometry'
|
|
|
+
|
|
|
+ def pairwise(self,iterable):
|
|
|
+ "s -> (s0, s1), (s2, s3), (s4, s5), ..."
|
|
|
+ valuelist = []
|
|
|
+
|
|
|
+ for item in iterable[0]:
|
|
|
+ a = iter(item)
|
|
|
+ valuelist.append(list(izip(a, a)))
|
|
|
+ return valuelist
|
|
|
+ pairwise.nargs = 1
|
|
|
+ pairwise.category = 'Conversion'
|
|
|
+
|
|
|
+ def KEEPOUTS(self,empty):
|
|
|
+ """Return all Keepouts of the board."""
|
|
|
+ b = _user_stacks['Board'][-1]
|
|
|
+ return filter(lambda c: c.IsKeepout(),[b.GetArea(i) for i in range(b.GetAreaCount())])
|
|
|
+ KEEPOUTS.nargs = 0
|
|
|
+ KEEPOUTS.category = 'Elements,Area'
|
|
|
+
|
|
|
+ def AREACORNERS(self,arealist):
|
|
|
+ """Area Corners."""
|
|
|
+ b=_user_stacks['Board'][-1]
|
|
|
+ areacorners = [[a.GetCornerPosition(i)
|
|
|
+ for i in range(a.GetNumCorners())]
|
|
|
+ for a in arealist[0]]
|
|
|
+ return areacorners
|
|
|
+ AREACORNERS.nargs = 1
|
|
|
+ AREACORNERS.category = 'Geometry,Area'
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ def fromsvg(self,inputs):
|
|
|
+ """[PATH_D_ATTRIBUTE SCALE] Converts SVG path element d attribute
|
|
|
+ to a list of coordinates suitable for drawelements. Applies SCALE
|
|
|
+ to all coordinates."""
|
|
|
+
|
|
|
+ path = inputs[0]
|
|
|
+ scale = inputs[1]
|
|
|
+ tokens = ['']
|
|
|
+ for char in path:
|
|
|
+ if char in '0123456789-+.':
|
|
|
+ tokens[-1] += char
|
|
|
+ continue
|
|
|
+ if tokens[-1]:
|
|
|
+ tokens.append('')
|
|
|
+ if char not in ' ,':
|
|
|
+ tokens[-1] += char
|
|
|
+ position = [0.0,0.0]
|
|
|
+ currenttoken = 0
|
|
|
+ listresult = []
|
|
|
+
|
|
|
+ scale = float(scale)
|
|
|
+ while currenttoken < len(tokens):
|
|
|
+ token = tokens[currenttoken]
|
|
|
+ try:
|
|
|
+ x = float(token)*scale
|
|
|
+ currenttoken += 1
|
|
|
+ y = float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ position[0] += x
|
|
|
+ position[1] += y
|
|
|
+ listresult[-1].append((position[0],position[1]))
|
|
|
+ continue
|
|
|
+ except:
|
|
|
+ if token == 'm':
|
|
|
+ currenttoken += 1
|
|
|
+ position[0] = float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ position[1] = float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ listresult.append([(position[0],position[1])])
|
|
|
+ continue
|
|
|
+ if token == 'l':
|
|
|
+ currenttoken += 1
|
|
|
+ position[0] += float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ position[1] += float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+
|
|
|
+ listresult[-1].append((position[0],position[1]))
|
|
|
+ continue
|
|
|
+ if token == 'h':
|
|
|
+ currenttoken += 1
|
|
|
+ position[0] += float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ listresult[-1].append((position[0],position[1]))
|
|
|
+ continue
|
|
|
+ if token == 'v':
|
|
|
+ currenttoken += 1
|
|
|
+ position[1] += float(tokens[currenttoken])*scale
|
|
|
+ currenttoken += 1
|
|
|
+ listresult[-1].append((position[0],position[1]))
|
|
|
+ continue
|
|
|
+ if token == 'z':
|
|
|
+ currenttoken += 1
|
|
|
+ listresult[-1].append(listresult[-1][0])
|
|
|
+ continue
|
|
|
+ output('Bad SVG token: %s'%token)
|
|
|
+ return listresult
|
|
|
+ fromsvg.nargs = 2
|
|
|
+ fromsvg.category = 'Geometry,Conversion'
|
|
|
+
|
|
|
+ def tocommand(self,elementlist,commandname):
|
|
|
+ """[ELEMENTLIST COMMANDNAME] Generate a command named COMMANDNAME that
|
|
|
+ draws the elements in ELEMENTLIST."""
|
|
|
+ kicommand.run(': %s "Draw Custom Drawing Command"'%commandname)
|
|
|
+ for element in elementlist:
|
|
|
+ s,e = element.GetStart(), element.GetEnd()
|
|
|
+ kicommand.run('%f,%f,%f,%f drawpoly'%(s[0],s[1],e[0],e[1]))
|
|
|
+ kicommand.run(';')
|
|
|
+ tocommand.nargs = 2
|
|
|
+ tocommand.category = 'Programming,Elements'
|
|
|
+
|
|
|
+ def REJOIN(self,empty):
|
|
|
+ 'Using selected lines, move multiple connected lines to the isolated line.'
|
|
|
+
|
|
|
+ run('drawings copytop selected')
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ lines_by_vertex = defaultdict(set)
|
|
|
+ for line in stack[-1]:
|
|
|
+
|
|
|
+ for p in (line.GetStart(),line.GetEnd()):
|
|
|
+ lines_by_vertex[(p.x,p.y)].add(line)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ line_by_lonelyvertex = filter(lambda x: len(x[1])==1, lines_by_vertex.iteritems())
|
|
|
+
|
|
|
+
|
|
|
+ lonely_line = []
|
|
|
+ connected_lines = []
|
|
|
+ for line in stack[-1]:
|
|
|
+ if len(lines_by_vertex[(line.GetStart().x,line.GetStart().y)]) == 1 \
|
|
|
+ and len(lines_by_vertex[(line.GetEnd().x,line.GetEnd().y)]) == 1:
|
|
|
+ lonely_line.append(line)
|
|
|
+ else:
|
|
|
+ connected_lines.append(line)
|
|
|
+ stack.pop()
|
|
|
+
|
|
|
+ if len(lonely_line) != 1:
|
|
|
+
|
|
|
+ return
|
|
|
+
|
|
|
+ lonely_line = lonely_line[0]
|
|
|
+ lonely_line_vertices = [(lonely_line.GetStart().x,lonely_line.GetStart().y),
|
|
|
+ (lonely_line.GetEnd().x,lonely_line.GetEnd().y)]
|
|
|
+ lonely_vertices = [tup[0] for tup in line_by_lonelyvertex]
|
|
|
+ lonely_vertices.remove(lonely_line_vertices[0])
|
|
|
+ lonely_vertices.remove(lonely_line_vertices[1])
|
|
|
+ output( type(list(lines_by_vertex[lonely_vertices[0]])[0]))
|
|
|
+ vector = lonely_line.GetStart() - list(lines_by_vertex[lonely_vertices[0]])[0].GetEnd()
|
|
|
+ output( "Moving by",vector)
|
|
|
+ for line in connected_lines:
|
|
|
+ output( '\t',line.GetStart(),line.GetEnd())
|
|
|
+ line.Move(vector)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ REJOIN.nargs = 0
|
|
|
+ REJOIN.category = 'Action',
|
|
|
+
|
|
|
+
|
|
|
+ def printf(self, *arglist):
|
|
|
+ 'Output [LISTOFLISTS FORMAT] Output each list within LISTOFLISTS formatted according to FORMAT in Pythons {} string format (https://www.python.org/dev/peps/pep-3101/).'
|
|
|
+ print('Format:',arglist[0][1])
|
|
|
+
|
|
|
+
|
|
|
+ for item in arglist[0][0]:
|
|
|
+ print "item:",item
|
|
|
+ output(arglist[0][1].format(*item))
|
|
|
+
|
|
|
+ def fprintf(self, *arglist):
|
|
|
+ 'Output [LISTOFLISTS FORMAT FILENAME] Output to FILENAME each list within LISTOFLISTS formatted according to FORMAT in Pythons {} string format (https://www.python.org/dev/peps/pep-3101/).'
|
|
|
+ arglist = arglist[0]
|
|
|
+
|
|
|
+ filename = os.path.join(os.getcwd(),arglist[2])
|
|
|
+ with open(filename,'w') as f:
|
|
|
+ for item in arglist[0]:
|
|
|
+
|
|
|
+ f.write(arglist[1].format(*item))
|
|
|
+
|
|
|
+ def pwd(self,empty):
|
|
|
+ "Programming Return the present working directory."
|
|
|
+ return os.getcwd()
|
|
|
+
|
|
|
+ def cduser(self,empty):
|
|
|
+ "Programming Change working directory to ~/kicad/kicommand."
|
|
|
+ os.chdir(USERSAVEPATH)
|
|
|
+
|
|
|
+ def cd(self,path):
|
|
|
+ "Programming [PATH] Change working directory to PATH."
|
|
|
+ os.chdir(path[0])
|
|
|
+
|
|
|
+ def cdproject(self,empty):
|
|
|
+ "Programming Return the project directory (location of .kicad_pcb file)."
|
|
|
+ os.chdir(PROJECTPATH)
|
|
|
+
|
|
|
+ def regex(self, *arglist):
|
|
|
+ 'Comparison [LIST REGEX] Create a LIST of True/False values corresponding to whether the values in LIST match the REGEX (for use prior to FILTER)'
|
|
|
+ stringlist, regex_ = arglist[0]
|
|
|
+
|
|
|
+
|
|
|
+ prog = re.compile(regex_)
|
|
|
+ return map(lambda s: prog.match(s),stringlist)
|
|
|
+
|
|
|
+ def callargs(self,*c):
|
|
|
+ 'Call [OBJECTLIST ARGLISTOFLISTS FUNCTION] Execute python FUNCTION on each member '
|
|
|
+ 'of OBJECTLIST with arguments in ARGLISTOFLISTS. ARGLISTOFLISTS can be '
|
|
|
+ 'a different length than OBJECTLIST, in which case ARGLISTOFLISTS '
|
|
|
+ 'elements will be repeated (or truncated) to match the length of '
|
|
|
+ 'OBJECTLIST. Returns the list of results in the same order as the '
|
|
|
+ 'original OBJECTLIST. The commands LIST and ZIP2 will be helpful '
|
|
|
+ 'here. ARGLISTOFLISTS can also be a single list or a single value, '
|
|
|
+ 'in which case the value will be converted to a list of lists.'
|
|
|
+ c = c[0]
|
|
|
+
|
|
|
+ args = c[1]
|
|
|
+
|
|
|
+ if hasattr(args,'__getitem__'):
|
|
|
+ if not hasattr(args[0],'__getitem__'):
|
|
|
+ args = [args]
|
|
|
+ else:
|
|
|
+ args = [[args]]
|
|
|
+
|
|
|
+ return map(lambda x:
|
|
|
+ getattr(x[0],c[2])(*(x[1])),
|
|
|
+ izip(c[0], cycle(args))
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+commands.classinstance = commands()
|
|
|
+for c in filter(lambda x: hasattr(getattr(commands,x), '__call__'),dir(commands)):
|
|
|
+ f = getattr(commands.classinstance,c)
|
|
|
+ if hasattr(f,'category'):
|
|
|
+ _dictionary ['command'][c.lower()] = Command(f.nargs,f,f.category,f.__doc__)
|
|
|
+ else:
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ nargs = 0
|
|
|
+ category, doc = f.__doc__.split(' ', 1)
|
|
|
+ if doc[0] == '[':
|
|
|
+ arg = doc[1:].split(']',1)[0].split()
|
|
|
+ if arg:
|
|
|
+ nargs = len(arg)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ _dictionary ['command'][c.lower()] = Command(nargs,f,category,doc)
|
|
|
+
|
|
|
+
|
|
|
+def rotate_point(point,center,angle,ccw=True):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if ccw:
|
|
|
+ mult = -1
|
|
|
+ else:
|
|
|
+ mult = 1
|
|
|
+ radians = mult*float(angle)*math.pi/180.0
|
|
|
+ radians = mult*float(angle)*math.pi/180.0
|
|
|
+ if not isinstance(point,pcbnew.wxPoint):
|
|
|
+ point = pcbnew.wxPoint(point[0],point[1])
|
|
|
+ if not isinstance(center,pcbnew.wxPoint):
|
|
|
+ center = pcbnew.wxPoint(center[0],center[1])
|
|
|
+ s = math.sin(radians)
|
|
|
+ c = math.cos(radians)
|
|
|
+ point = point - center
|
|
|
+
|
|
|
+ point = pcbnew.wxPoint(point[0]*c - point[1]*s,point[0]*s + point[1]*c)
|
|
|
+ point = point + center
|
|
|
+
|
|
|
+ return point
|
|
|
+
|
|
|
+def ROTATEPOINTS(points,center,angle):
|
|
|
+
|
|
|
+ center = convert_to_points(center)[0]
|
|
|
+ points = convert_to_points(points)
|
|
|
+ if not hasattr(angle,'__iter__'):
|
|
|
+ angle = [angle]
|
|
|
+
|
|
|
+
|
|
|
+ newps = []
|
|
|
+
|
|
|
+ for ps,c,a in izip(points, cycle(center),cycle(angle)):
|
|
|
+ newps.append([rotate_point(p,c,float(a)) for p in ps])
|
|
|
+
|
|
|
+
|
|
|
+ return newps
|
|
|
+
|
|
|
+def REMOVE(items):
|
|
|
+ if not hasattr(items,'__iter__'):
|
|
|
+ items = [items]
|
|
|
+ b = _user_stacks['Board'][-1]
|
|
|
+ d=b.GetDrawings().Remove
|
|
|
+ t=b.GetTracks().Remove
|
|
|
+ m=b.GetModules().Remove
|
|
|
+ access = ((pcbnew.TRACK,t),(pcbnew.MODULE,m),(object,d))
|
|
|
+ for item in items:
|
|
|
+ for inst,remove in access:
|
|
|
+ output(str(inst),str(remove))
|
|
|
+ if isinstance(item,inst):
|
|
|
+ remove(item)
|
|
|
+ continue
|
|
|
+
|
|
|
+
|
|
|
+def TOCOPPER(*c):
|
|
|
+ objects,layer = c
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ try:
|
|
|
+ layerID = int(layer)
|
|
|
+ except:
|
|
|
+ layerID = board.GetLayerID(str(layer))
|
|
|
+
|
|
|
+ for object in objects:
|
|
|
+ track = pcbnew.TRACK(board)
|
|
|
+ track.SetStart(object.GetStart())
|
|
|
+ track.SetEnd(object.GetEnd())
|
|
|
+ track.SetWidth(object.GetWidth())
|
|
|
+ track.SetLayer(layerID)
|
|
|
+
|
|
|
+ board.Add(track)
|
|
|
+
|
|
|
+def CORNERS(c):
|
|
|
+ if (not hasattr(c,'__iter__')) and \
|
|
|
+ ((hasattr(c,'GetSize') and hasattr(c,'GetCenter')) or \
|
|
|
+ isinstance(c,pcbnew.EDA_RECT) or \
|
|
|
+ isinstance(c[0],pcbnew.wxPoint)):
|
|
|
+ rects = [c]
|
|
|
+ else:
|
|
|
+ rects = c
|
|
|
+
|
|
|
+
|
|
|
+ aggregate = []
|
|
|
+ for r in rects:
|
|
|
+ if hasattr(r,'GetCenter') and hasattr(r,'GetSize'):
|
|
|
+ ns = pcbnew.wxPoint(r.GetSize()[0]/2.0,r.GetSize()[1]/2.0)
|
|
|
+ aggregate.append(pcbnew.EDA_RECT(r.GetCenter()-ns,r.GetSize()))
|
|
|
+ elif hasattr(r,'GetBoundingBox'):
|
|
|
+ aggregate.append(r.GetBoundingBox())
|
|
|
+ else:
|
|
|
+ aggregate.append(r)
|
|
|
+ rects = aggregate
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ xyvals = []
|
|
|
+ for poly in rects:
|
|
|
+ if isinstance(poly,pcbnew.EDA_RECT):
|
|
|
+ l,r,t,b = poly.GetLeft(),poly.GetRight(),poly.GetTop(),poly.GetBottom()
|
|
|
+ xyvals.append((l,t,r,t,r,b,l,b,l,t))
|
|
|
+
|
|
|
+ return xyvals
|
|
|
+def CORNERS_old(c):
|
|
|
+ if (not hasattr(c,'__iter__')) and \
|
|
|
+ (hasattr(c,'GetBoundingBox') or \
|
|
|
+ isinstance(c,pcbnew.EDA_RECT) or \
|
|
|
+ isinstance(c[0],pcbnew.wxPoint)):
|
|
|
+ rects = [c]
|
|
|
+ else:
|
|
|
+ rects = c
|
|
|
+
|
|
|
+
|
|
|
+ aggregate = []
|
|
|
+ for r in rects:
|
|
|
+ if hasattr(r,'GetBoundingBox'):
|
|
|
+ aggregate.append(r.GetBoundingBox())
|
|
|
+ else:
|
|
|
+ aggregate.append(r)
|
|
|
+ rects = aggregate
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ xyvals = []
|
|
|
+ for poly in rects:
|
|
|
+ if isinstance(poly,pcbnew.EDA_RECT):
|
|
|
+ l,r,t,b = poly.GetLeft(),poly.GetRight(),poly.GetTop(),poly.GetBottom()
|
|
|
+ xyvals.append((l,t,r,t,r,b,l,b,l,t))
|
|
|
+
|
|
|
+ return xyvals
|
|
|
+
|
|
|
+import inspect
|
|
|
+USERSAVEPATH = os.path.join(os.path.expanduser('~'),'kicad','kicommand')
|
|
|
+os.chdir(USERSAVEPATH)
|
|
|
+
|
|
|
+KICOMMAND_MODULE_DIR = os.path.dirname(inspect.stack()[0][1])
|
|
|
+LOADABLE_DIR = os.path.join(KICOMMAND_MODULE_DIR,'loadable')
|
|
|
+USERLOADPATH = USERSAVEPATH+':'+LOADABLE_DIR
|
|
|
+PROJECTPATH = os.path.dirname(pcbnew.GetBoard().GetFileName())
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def LOAD(name,path=USERLOADPATH):
|
|
|
+ for p in path.split(':'):
|
|
|
+ new_path = os.path.join(p, name)
|
|
|
+ if not os.path.isfile(new_path):
|
|
|
+ continue
|
|
|
+ with open(new_path,'r') as f: run(f.read())
|
|
|
+
|
|
|
+def SAVE(name):
|
|
|
+ dictname = 'user'
|
|
|
+ if not os.path.exists(USERSAVEPATH):
|
|
|
+ os.makedirs(USERSAVEPATH)
|
|
|
+ output('created ~/kicad/kicommand')
|
|
|
+ output("saving to %s"%name)
|
|
|
+ new_path = os.path.join(USERSAVEPATH, name)
|
|
|
+ with open(new_path,'w') as f:
|
|
|
+ commands = _dictionary[dictname].iteritems()
|
|
|
+ for command,definition in sorted(commands,key=lambda x:x[0]):
|
|
|
+ f.write( ": %s %s ;\n"%(command,_dictionary[dictname][command]))
|
|
|
+
|
|
|
+def EXPLAIN(commandstring,category=None):
|
|
|
+ output('Explaining',commandstring)
|
|
|
+ commands = commandstring.split(',')
|
|
|
+ commands.reverse()
|
|
|
+ printed = set()
|
|
|
+ count = 0
|
|
|
+ while commands:
|
|
|
+ count += 1
|
|
|
+ if count > 100:
|
|
|
+ output('explain command has limit of 100 command output.')
|
|
|
+ break
|
|
|
+ command = commands.pop()
|
|
|
+ if not command:
|
|
|
+ continue
|
|
|
+ if command in printed:
|
|
|
+ output(('%s (see explanation above)'%(command)))
|
|
|
+ continue
|
|
|
+ else:
|
|
|
+ found = None
|
|
|
+ printed.add(command)
|
|
|
+ for dictname in ['user','persist']:
|
|
|
+
|
|
|
+ if command in _dictionary[dictname]:
|
|
|
+ found = _dictionary[dictname][command]
|
|
|
+ if isinstance(found,basestring):
|
|
|
+ found = found.split()
|
|
|
+ output( ': %s %s ;'%(command,' '.join(found)))
|
|
|
+ found.reverse()
|
|
|
+ commands.extend(found)
|
|
|
+ else:
|
|
|
+ print_command_detail(command)
|
|
|
+ break;
|
|
|
+ if not found:
|
|
|
+ if not print_command_detail(command):
|
|
|
+ output( '%s - A literal value (argument)'%command)
|
|
|
+
|
|
|
+ else:
|
|
|
+ printed.add(command)
|
|
|
+
|
|
|
+def HELPALL():
|
|
|
+ sorted = list(_command_dictionary.keys())
|
|
|
+ sorted.sort()
|
|
|
+ for command in sorted:
|
|
|
+ print_command_detail(command)
|
|
|
+
|
|
|
+def print_command_detail(command):
|
|
|
+ for dictname in ('user','persist','command'):
|
|
|
+ v = _dictionary[dictname].get(command,None)
|
|
|
+ if v:
|
|
|
+ break
|
|
|
+ if not v:
|
|
|
+ return False
|
|
|
+
|
|
|
+
|
|
|
+ output(('%s (Category: %s)'%(command,v.category)))
|
|
|
+ output(('\t%s'%'\n'.join(['\n\t'.join(wrap(block, width=60)) for block in v.helptext.splitlines()])))
|
|
|
+ return True
|
|
|
+
|
|
|
+
|
|
|
+def HELPMAIN():
|
|
|
+ helptext = ' '.join("""
|
|
|
+ KiCommand gives you quick access to objects in pcbnew for manipulation or information.
|
|
|
+ Enter arguments (if any) prior to commands and use previous results for succeeding commands.
|
|
|
+ Simple commands allow you to create useful command strings. For more information,
|
|
|
+ use one of the following commands in the Help category:""".split())
|
|
|
+ output(('\t%s'%'\n'.join(['\n\t'.join(wrap(block, width=60)) for block in helptext.splitlines()])))
|
|
|
+ output( 'All helpcat - For a list of all commands by category.')
|
|
|
+ output( "'COMMAND explain - For help on a specific COMMAND (be sure to include the single quote).")
|
|
|
+ output("helpall - for detailed help on all commands.")
|
|
|
+ output()
|
|
|
+
|
|
|
+ commands = 'helpcat explain helpall'.split()
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for command in commands:
|
|
|
+ print_command_detail(command)
|
|
|
+
|
|
|
+def HELPCAT(category):
|
|
|
+
|
|
|
+ uniondict = {}
|
|
|
+ commands = []
|
|
|
+
|
|
|
+ for dictname in ('user','persist','command'):
|
|
|
+ uniondict.update(_dictionary[dictname])
|
|
|
+
|
|
|
+ if category == 'Core':
|
|
|
+ commands = _command_dictionary.iteritems()
|
|
|
+ elif category == 'All':
|
|
|
+ commands = uniondict.iteritems()
|
|
|
+
|
|
|
+ if commands:
|
|
|
+ cbyc = defaultdict(list)
|
|
|
+ for command in commands:
|
|
|
+
|
|
|
+ try:
|
|
|
+ catlist = command[1].category.split(',')
|
|
|
+ except:
|
|
|
+ catlist = command[1].category
|
|
|
+ for cat in catlist:
|
|
|
+ cbyc[cat].append(command[0])
|
|
|
+ catlen = max(map(len,cbyc.keys()))
|
|
|
+
|
|
|
+
|
|
|
+ output( '{:<{width}} - {}'.format('CATEGORY','COMMANDS IN THIS CATEGORY', width=catlen))
|
|
|
+ for cat in sorted(cbyc.keys()):
|
|
|
+ output( '{:<{width}} - {}'.format(cat,' '.join(cbyc[cat]), width=catlen))
|
|
|
+ return
|
|
|
+
|
|
|
+ try:
|
|
|
+ catset = set(category.split(','))
|
|
|
+ except:
|
|
|
+ catset = set(category)
|
|
|
+
|
|
|
+ commands = filter(lambda c: hasattr(c[1],'category') and catset.intersection(c[1].category.split(',') if hasattr(c[1].category,'split') else c[1].category), uniondict.iteritems())
|
|
|
+ commands = [command[0] for command in commands]
|
|
|
+ commands.sort()
|
|
|
+ for command in commands:
|
|
|
+ print_command_detail(command)
|
|
|
+
|
|
|
+def floatnoerror(value):
|
|
|
+ try:
|
|
|
+ return float(value)
|
|
|
+ except:
|
|
|
+ return value
|
|
|
+def intnoerror(value):
|
|
|
+ try:
|
|
|
+ return int(value)
|
|
|
+ except:
|
|
|
+ return value
|
|
|
+def multiplynoerror(value,multiplier):
|
|
|
+ try:
|
|
|
+ f = float(value)
|
|
|
+ except:
|
|
|
+ return value
|
|
|
+ return f*multiplier
|
|
|
+
|
|
|
+def HELP(textlist,category=None,exact=False):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if isinstance(textlist,basestring):
|
|
|
+ textlist = [textlist]
|
|
|
+ for text in textlist:
|
|
|
+ textspace = text.split()
|
|
|
+ if len(textspace) > 1:
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+
|
|
|
+
|
|
|
+ pass
|
|
|
+ if text.find(' '):
|
|
|
+ pass
|
|
|
+
|
|
|
+ if category == 'All':
|
|
|
+ foundkv = _command_dictionary.iteritems()
|
|
|
+ command_by_category = defaultdict(list)
|
|
|
+ for command,val in _command_dictionary.iteritems():
|
|
|
+
|
|
|
+ command_by_category[val.category].append(command)
|
|
|
+
|
|
|
+ for category,commands in sorted(command_by_category.iteritems(),key=lambda x:x[0]):
|
|
|
+ output('%11s: %s\n'%(category,' '.join(commands))),
|
|
|
+ return
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if text:
|
|
|
+ if exact:
|
|
|
+ foundkv = text,_command_dictionary.get(text,None)
|
|
|
+ else:
|
|
|
+ foundkv = filter(lambda x: x[0].find(text)!=-1,_command_dictionary.iteritems())
|
|
|
+ else:
|
|
|
+ foundkv = _command_dictionary.iteritems()
|
|
|
+
|
|
|
+ if not foundkv or not foundkv[1]:
|
|
|
+ continue
|
|
|
+ foundkv = sorted(foundkv,key=lambda x: x[0])
|
|
|
+ for commandandvalue in foundkv:
|
|
|
+ output( commandandvalue)
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+_command_dictionary.update({
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'pcbnew': Command(0,lambda c: pcbnew,'Elements',
|
|
|
+ 'Get the base object for PCBNEW'),
|
|
|
+ 'getboard': Command(0,lambda c: pcbnew.GetBoard(),'Elements',
|
|
|
+ 'Get the Board object'),
|
|
|
+ 'board': Command(0,lambda c: _user_stacks['Board'][-1],'Elements',
|
|
|
+ 'Get the Board object'),
|
|
|
+ 'modules': Command(0,lambda c: _user_stacks['Board'][-1].GetModules(),'Elements',
|
|
|
+ 'Get all modules'),
|
|
|
+ 'tracks': Command(0,lambda c: _user_stacks['Board'][-1].GetTracks(),'Elements',
|
|
|
+ 'Get all tracks (including vias)'),
|
|
|
+ 'drawings': Command(0,lambda c: _user_stacks['Board'][-1].GetDrawings(),'Elements',
|
|
|
+ 'Get all top-level drawing objects (lines and text)'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'selected': Command(1,lambda c: filter(lambda x: x.IsSelected(), c[0]),'Attributes',
|
|
|
+ '[objects] Get selected objects '),
|
|
|
+ 'notselected': Command(1,lambda c: filter(lambda x: not x.IsSelected(), c[0]),'Attributes',
|
|
|
+ '[objects] Get unselected objects '),
|
|
|
+ 'attr': Command(2,lambda c: map(lambda x: getattr(x,c[1]), c[0]),'Attributes',
|
|
|
+ '[objects attribute] Get specified python attribute of the objects' ),
|
|
|
+
|
|
|
+
|
|
|
+ 'sindex': Command(2,lambda c: c[0][c[1]],'Attributes',
|
|
|
+ '[DICTIONARYOBJECT STRINGINDEX] Select an item in the list of objects based on string INDEX'),
|
|
|
+
|
|
|
+ 'index.': Command(2, lambda c: map(lambda x: x[int(c[1])],c[0]), 'Conversion',
|
|
|
+ '[LISTOFLISTS INDEX] return a list made up of the INDEX item of each list in LISTOFLISTS'),
|
|
|
+ 'index': Command(2,
|
|
|
+ lambda c: c[0][int(c[1])] if isinstance(c[1],basestring) \
|
|
|
+ and c[1].find(',') == -1 else map(lambda x: x[0][int(x[1])],
|
|
|
+ izip(c[0], cycle(c[1].split(','))
|
|
|
+ if isinstance(c[1],basestring) else c[1]
|
|
|
+ )),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'Programming',
|
|
|
+ '[LIST INDEX] Select an item in the list of objects based on numeric index. '
|
|
|
+ 'If INDEX is a list of integers or a comma separated list of numbers, then '
|
|
|
+ 'each number in INDEX will be applied to the corresponding item in the LIST of '
|
|
|
+ 'lists, where the INDEX list is repeated or truncated as necessary.'
|
|
|
+ ),
|
|
|
+
|
|
|
+
|
|
|
+ 'connect': Command(1,lambda c: CONNECT(*c),'Action',
|
|
|
+ 'Using selected lines, connect all vertices to each closest one.'),
|
|
|
+
|
|
|
+ 'length': Command(1, lambda c: LENGTH(*c),'Geometry',
|
|
|
+ '[SEGMENTLIST] Get the length of each segment (works with '
|
|
|
+ 'segment and arc types'),
|
|
|
+ 'setlength': Command(2, lambda c: SETLENGTH(*c),'Geometry',
|
|
|
+ '[SEGMENTLIST LENGTH] Set the length of each segment. Move connected segments accordingly.'),
|
|
|
+ 'ends': Command(1, lambda c: get_ds_ends(*c),'Geometry',
|
|
|
+ 'Get the end points of the drawsegment (works with segment and arc types'),
|
|
|
+ 'connected': Command(2,lambda c: CONNECTED(*c),'Filter',
|
|
|
+ '[WHOLE INITIAL] From objects in WHOLE, return those that are connected to objects in INITIAL (recursevely)'),
|
|
|
+ 'matchreference': Command(2,lambda c: filter(lambda x: x.GetReference() in c[1].split(','), c[0]),'Filter',
|
|
|
+ '[MODULES REFERENCE] Filter the MODULES and retain only those that match REFERENCE'),
|
|
|
+
|
|
|
+ 'extend': Command(2,lambda c: c[0].extend(c[1]),'Stack',
|
|
|
+ '[LIST1 LIST2] Join LIST1 and LIST2'),
|
|
|
+
|
|
|
+ 'filter': Command(2,lambda c: list(compress(c[0], c[1])),'Filter',
|
|
|
+ '[LIST1 TF_LIST] Retain objects in LIST1 where the corresponding value in TF_LIST is True, not None, not zero, and not zero length'),
|
|
|
+
|
|
|
+ '<': Command(2,lambda c: map(lambda x: float(x)<float(c[1]),c[0]),'Comparison',
|
|
|
+ '[LIST VALUE] Create a LIST of True/False values corresponding to whether the values in LIST are less than VALUE (for use prior to FILTER)'),
|
|
|
+ 'filtertype': Command(2,lambda c: filter(lambda x:isinstance(x,getattr(pcbnew,c[1])),c[0]),'Comparison',
|
|
|
+ '[LIST TYPE] Retains objects in LIST that are of TYPE' ),
|
|
|
+ 'istype': Command(2,lambda c: filter(lambda x:isinstance(x,getattr(pcbnew,c[1])),c[0]),'Comparison',
|
|
|
+ '[LIST TYPE] Create a LIST of True/False values corresponding to whether '
|
|
|
+ 'the values in LIST are of TYPE (for use prior to FILTER). '
|
|
|
+ 'TYPE must be an attribute of pcbnew.' ),
|
|
|
+ '=': Command(2,lambda c: map(lambda x: x==c[1],c[0]),'Comparison',
|
|
|
+ '[LIST VALUE] Create a LIST of True/False values corresponding to whether the values in LIST equal to VALUE (for use prior to FILTER)'),
|
|
|
+ 'isnone': Command(1,lambda c: map(lambda x: x is None,c[0]),'Comparison',
|
|
|
+ '[LIST VALUE] Create a LIST of True/False values corresponding to whether the values in LIST equal to None (for use prior to FILTER)'),
|
|
|
+ 'isnotnone': Command(1,lambda c: map(lambda x: x is not None,c[0]),'Comparison',
|
|
|
+ '[LIST VALUE] Create a LIST of True/False values corresponding to whether the values in LIST is not None (for use prior to FILTER)'),
|
|
|
+
|
|
|
+ 'undock': Command(0,lambda c: UNDOCK(*c),'Interface',
|
|
|
+ 'Undock the window.'),
|
|
|
+ 'spush': Command(2,lambda c: _user_stacks[c[1]].append(c[0]),'Programming',
|
|
|
+ '[STACK] [VALUE] Push VALUE onto the named STACK.'),
|
|
|
+ 'spop': Command(1,lambda c: _user_stacks[c[0]].pop(),'Programming',
|
|
|
+ '[STACK] Pop the top of the user STACK onto the main stack.'),
|
|
|
+ 'scopy': Command(1,lambda c: _user_stacks[c[0]][-1],'Programming',
|
|
|
+ '[STACK] Copy the top of the user STACK onto the main stack.'),
|
|
|
+ 'stack': Command(0,lambda c: STACK(*c),'Programming',
|
|
|
+ 'Output the string representation of the objects on the stack'),
|
|
|
+ 'print': Command(0,lambda c: PRINT(*c),'Programming',
|
|
|
+ 'Output the string representation of the top object on the stack'),
|
|
|
+ 'builtins': Command(0,lambda c: __builtins__,'Programming',
|
|
|
+ 'Output the __builtins__ Python object, giving access to the built in Python functions.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'calllist': Command(2,lambda c: CALLLIST(*c),'Call',
|
|
|
+ '[LIST FUNCTION] Execute python FUNCTION on each member of LIST.'
|
|
|
+ 'The FUNCTION must return a list of items (this is suitable'
|
|
|
+ 'for module functions such as GraphicalItems and Pads.'),
|
|
|
+ 'fcall': Command(1,lambda c: map(lambda x: x(), c[0]),'Call',
|
|
|
+ '[FUNCTIONLIST] Execute each python function in the FUNCTIONLIST on each member of LIST. Return the list of results in the same order as the original LIST.'),
|
|
|
+ 'fcallargs': Command(2,
|
|
|
+ lambda c:
|
|
|
+ map(lambda x:
|
|
|
+ x[0](*(x[1])),
|
|
|
+ izip(c[0], cycle(c[1]))
|
|
|
+ )
|
|
|
+ ,'Call',
|
|
|
+ '[FUNCTIONLIST ARGLISTOFLISTS] Execute each python function in the'
|
|
|
+ 'FUNCTIONLIST on each member of that list with arguments in ARGLISTOFLISTS.' 'ARGLISTOFLISTS can be '
|
|
|
+ 'a different length than OBJECTLIST, in which case ARGLISTOFLISTS '
|
|
|
+ 'elements will be repeated (or truncated) to match the length of '
|
|
|
+ 'OBJECTLIST. Returns the list of results in the same order as the '
|
|
|
+ 'original OBJECTLIST. The commands LIST and ZIP2 will be helpful '
|
|
|
+ 'here.'),
|
|
|
+
|
|
|
+
|
|
|
+ 'call': Command(2,lambda c: map(lambda x: getattr(x,c[1])(), c[0])
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ ,'Call',
|
|
|
+ '[LIST FUNCTION] Execute python FUNCTION on each member of LIST. Return the list of results in the same order as the original LIST.'),
|
|
|
+ 'callfilter': Command(2,lambda c: filter(lambda x: getattr(x,c[1])(), c[0]),'Call',
|
|
|
+ '[LIST FUNCTION] Execute python FUNCTION on each member of LIST. Return results that return True.'),
|
|
|
+ 'callnotfilter': Command(2,lambda c: filter(lambda x: not getattr(x,c[1])(), c[0]),'Call',
|
|
|
+ '[LIST FUNCTION] Execute python FUNCTION on each member of LIST. Return results that return False.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ '+.': Command(2,lambda c:
|
|
|
+ [float(a)+float(b) for a,b in izip(c[0], cycle(c[1]))],'Numeric',
|
|
|
+ '[LIST1 LIST2] Return the the floating point LIST1 + LIST2 member by member.'),
|
|
|
+ '*.': Command(2,lambda c:
|
|
|
+ [float(a)*float(b) for a,b in izip(c[0], cycle(c[1]))],'Numeric',
|
|
|
+ '[LIST1 LIST2] Return the the floating point LIST1 * LIST2 member by member.'),
|
|
|
+ '+': Command(2,lambda c:
|
|
|
+ float(c[0])+float(c[1]),'Numeric',
|
|
|
+ '[OPERAND1 OPERAND2] Return the the floating point OPERAND1 + OPERAND2.'),
|
|
|
+ '-': Command(2,lambda c: float(c[0])-float(c[1]),'Numeric',
|
|
|
+ '[OPERAND1 OPERAND2] Return the the floating point OPERAND1 - OPERAND2.'),
|
|
|
+ '*': Command(2,lambda c: float(c[0])*float(c[1]),'Numeric',
|
|
|
+ '[OPERAND1 OPERAND2] Return the the floating point OPERAND1 * OPERAND2.'),
|
|
|
+ '/': Command(2,lambda c: float(c[0])/float(c[1]),'Numeric',
|
|
|
+ '[OPERAND1 OPERAND2] Return the the floating point OPERAND1 / OPERAND2.'),
|
|
|
+ 'sum': Command(1,lambda c: sum(*c),'Numeric',
|
|
|
+ '[LIST] Return the sum of all members in LIST.'),
|
|
|
+
|
|
|
+
|
|
|
+ 'append': Command(2,lambda c: c[0]+c[1],'Stack',
|
|
|
+ '[OPERAND1 OPERAND2] Return LIST1 and LIST2 concatenated together.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'clear': Command(0,lambda c: CLEAR(*c),'Stack',
|
|
|
+ 'Clear the stack.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'float': Command(1,
|
|
|
+ lambda c: floatnoerror(c[0]) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: floatnoerror(x),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a floating point value or list. OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of numbers.', ),
|
|
|
+ 'bool': Command(1,
|
|
|
+
|
|
|
+ lambda c: bool(c[0]) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: bool(x),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a boolean value or list. OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of values.', ),
|
|
|
+ 'int': Command(1,
|
|
|
+
|
|
|
+ lambda c: intnoerror(c[0]) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: intnoerror(x),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a floating point value or list. OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of numbers.', ),
|
|
|
+ 'string': Command(1,lambda c: str(c[0]),'Conversion',
|
|
|
+ '[OBJECT] Convert OBJECT to a string.'),
|
|
|
+ 'dict': Command(2,lambda c: dict(zip(*c)),'Conversion',
|
|
|
+ '[KEYS VALUES] Create a dictionary from KEYS and VALUES lists.'),
|
|
|
+
|
|
|
+ 'mm': Command(1,
|
|
|
+ lambda c: multiplynoerror(c[0],pcbnew.IU_PER_MM) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: multiplynoerror(x,pcbnew.IU_PER_MM),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a floating point value or list converted '
|
|
|
+ 'from mm to native units (nm). OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of numbers.'),
|
|
|
+ 'mil': Command(1,
|
|
|
+ lambda c: multiplynoerror(c[0],pcbnew.IU_PER_MILS) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: multiplynoerror(x,pcbnew.IU_PER_MILS),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a floating point value or list converted '
|
|
|
+ 'from mils to native units (nm). OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of numbers.'),
|
|
|
+ 'mils': Command(1,
|
|
|
+ lambda c: multiplynoerror(c[0],pcbnew.IU_PER_MILS) if isinstance(c[0],basestring) \
|
|
|
+ and c[0].find(',') == -1 else map(lambda x: multiplynoerror(x,pcbnew.IU_PER_MILS),
|
|
|
+ c[0].split(',')
|
|
|
+ if isinstance(c[0],basestring) else c[0]
|
|
|
+ if hasattr(c[0],'__iter__') else [c[0]]),
|
|
|
+ 'Conversion',
|
|
|
+ '[OBJECT] Return OBJECT as a floating point value or list converted '
|
|
|
+ 'from mils to native units (nm). OBJECT can '
|
|
|
+ 'be a string, a comma separated list of values, a list of strings, or '
|
|
|
+ 'list of numbers.'),
|
|
|
+ 'split': Command(1,lambda c: c[0].split(','),'Conversion',
|
|
|
+ '[STRING] Split STRING on commas into a list of strings'),
|
|
|
+
|
|
|
+ 'iset': Command(1,lambda c: set(c[0]),'Conversion',
|
|
|
+ '[ITERABLE] Make a set from ITERABLE where each item is a member of ITERABLE.'),
|
|
|
+ 'ilist': Command(1,lambda c: list(c[0]),'Conversion',
|
|
|
+ '[ITERABLE] Make list from ITERABLE where each item is a member of ITERABLE.'),
|
|
|
+ 'list': Command(1,lambda c: [c[0]],'Conversion',
|
|
|
+ '[OBJECT] Make OBJECT into a list (with only OBJECT in it).'),
|
|
|
+ 'delist': Command(1,lambda c: c[0][0],'Conversion',
|
|
|
+ '[LIST] Output index 0 of LIST.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'pick': Command(1,lambda c: stack.insert(-1,stack[-int(c[0])-2]),'Stack',
|
|
|
+ '[NUMBER] Copy the value that is NUMBER of objects deep in the stack to the top of the stack. '
|
|
|
+ '\n\tExamples:\n\t0 pick - copies the top of the stack.\n'
|
|
|
+ '\t1 pick - pushes a copy of the second item from the top of the stack onto the top of the stack.\n'
|
|
|
+ ),
|
|
|
+ 'swap': Command(0,lambda c: SWAP(*c),'Stack',
|
|
|
+ 'Switches the two top objects on the stack.'),
|
|
|
+ 'zip2': Command(2,lambda c: zip(*c),'Stack',
|
|
|
+ '[LIST1 LIST2] Creates a list with parallel objects in LIST1 and '
|
|
|
+ 'LIST2 together at the same index.'),
|
|
|
+ 'zip': Command(1,lambda c: zip(*c[0]),'Stack',
|
|
|
+ '[LISTOFLISTS] Creates a list with parallel objects formed by each list '
|
|
|
+ 'in LISTOFLISTS ((1,2,3)(4,5,6)(7,8,9)) -> ((1,4,7)(2,5,8)(3,6,9)).'
|
|
|
+ ),
|
|
|
+ ':': Command(0,lambda c: setcompilemode(True),'Programming',
|
|
|
+ 'Begin the definition of a new command. This is the only command in '
|
|
|
+ 'which arguments occur after the command. Command definition ends with '
|
|
|
+ 'the semicolon (;). Run command SEEALL for more examples. Special commands are'
|
|
|
+ "Delete all commands ': ;'. Delete a command ': COMMAND ;"
|
|
|
+ ),
|
|
|
+
|
|
|
+ ':persist': Command(0,lambda c: setcompilemode(True,'persist'),'Programming',
|
|
|
+ 'Begin the definition of a new command in the persist dictionary. '
|
|
|
+ 'This is the only type of command in '
|
|
|
+ 'which arguments occur after the command. Command definition ends with '
|
|
|
+ 'the semicolon (;). Run command SEEALL for more examples.'
|
|
|
+ ),
|
|
|
+
|
|
|
+ 'rotatepoints': Command(3,lambda c: ROTATEPOINTS(*c),'Geometry',
|
|
|
+ '[POINTS CENTER DEGREES] Rotate POINTS around CENTER. POINTS can be in '
|
|
|
+ 'multiple formats such as EDA_RECT or a list of one or more points.'),
|
|
|
+ 'rotate': Command(2,lambda c: ROTATE(*c),'Geometry',
|
|
|
+ '[SEGMENTLIST DEGREES] Rotate segments by DEGREES around calculated '
|
|
|
+ 'average center.'),
|
|
|
+
|
|
|
+ 'corners': Command(1,lambda c: CORNERS(*c),'Geometry',
|
|
|
+ "[OBJECT] OBJECT is either a single object or a list of objects. "
|
|
|
+ "Converts each OBJECT, either EDA_RECT or OBJECT's BoundingBox "
|
|
|
+ "into vertices appropriate for drawpoly."
|
|
|
+ ),
|
|
|
+
|
|
|
+ 'tocopper': Command(2,lambda c: TOCOPPER(*c),'Layer',
|
|
|
+ "[DRAWSEGMENTLIST LAYER] put each DRAWSEGMENT on the copper LAYER."),
|
|
|
+
|
|
|
+ 'layernums': Command(1,lambda c: [_user_stacks['Board'][-1].GetLayerID(x) for x in c[0].split(',')],'Layer',
|
|
|
+ '[STRING] Get the layer numbers for each layer in comma separated STRING. '
|
|
|
+ 'STRING can also be one number, if desired.'),
|
|
|
+ 'onlayers': Command(2,lambda c: filter(lambda x: set(x.GetLayerSet().Seq()).intersection(set(c[1])),c[0]),'Layer',
|
|
|
+ '[LIST LAYERS] Retains the objects in LIST that exist on any of the LAYERS.'),
|
|
|
+ 'setlayer': Command(2,lambda c: map(lambda x: x.SetLayer(layer(c[1])),
|
|
|
+ c[0] if hasattr(c[0],'__iter__') else list(c[0])), 'Layer',
|
|
|
+ '[OBJECTS LAYER] Moves all OBJECTS to LAYER.'),
|
|
|
+ 'pop': Command(1,lambda c: None,'Stack',
|
|
|
+ 'Removes the top item on the stack.'),
|
|
|
+ 'see': Command(1,lambda c: print_userdict(*c),'Help',
|
|
|
+ '[COMMAND] Shows previously-defined COMMAND from the user dictionary. '
|
|
|
+ 'See the colon (:) command for more information.'),
|
|
|
+ 'seeall': Command(0,lambda c: print_userdict(*c),'Help',
|
|
|
+ '[COMMAND] Shows all previously-defined COMMANDs from the user dictionary. '
|
|
|
+ 'See the colon (:) command for more information.'),
|
|
|
+ 'now': Command(0,lambda c: time.asctime(),'System',
|
|
|
+ 'Returns the current system time as a string.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ 'makeangle': Command(2,lambda c:MAKEANGLE(*c),'Draw',
|
|
|
+ '[SEGMENTLIST ANGLE] Make the selected segments form '
|
|
|
+ 'the specified angle. arc radius is maintained, though angle and '
|
|
|
+ 'position are modified, while line segments are moved '
|
|
|
+ 'and stretched to be +/- n*angle specified.'),
|
|
|
+ 'regular': Command(1,lambda c:REGULAR(*c),'Draw',
|
|
|
+ '[SEGMENTLIST] Move/stretch the selected segments into a regular '
|
|
|
+ 'polygon (equal length sides, equal angles).'),
|
|
|
+ 'grid': Command(2,lambda c:GRID(*c),'Draw',
|
|
|
+ '[SEGMENTLIST GRID] Move points of SEGMENTLIST to be a multiple of GRID.'),
|
|
|
+ 'scale': Command(2,lambda c:SCALE(*c),'Draw',
|
|
|
+ '[SEGMENTLIST FACTOR] Scale each item in SEGMENTLIST by FACTOR, using '
|
|
|
+ 'the midpoint of all segments as the center.'),
|
|
|
+ 'cut': Command(0,lambda c: CUT(*c),'Draw',
|
|
|
+ 'Cut all segments with the selected segment at the intersection. Then remove the cutting (selected) segment.'),
|
|
|
+ 'round': Command(2,lambda c: draw_arc_to_segments(*c),'Draw',
|
|
|
+ '[RADIUS SEGMENTLIST] Round the corners of connected line segments '
|
|
|
+ 'within SEGMENTLIST by adding ARCs of specified RADIUS.'),
|
|
|
+ 'angle': Command(1,lambda c: ANGLE(*c),'Geometry',
|
|
|
+ '[SEGMENTLIST] Return the angle of each segment in SEGMENTLIST.'),
|
|
|
+ 'drawarctest':Command(1,lambda c: draw_arc(50*pcbnew.IU_PER_MM,50*pcbnew.IU_PER_MM,radius,angle,layer=_user_stacks['drawparams']['l'],thickness=_user_stacks['drawparams']['t']),'Draw',
|
|
|
+ ""),
|
|
|
+ 'drawarc':Command(2,lambda c: draw_arc(c[0][0],c[0][1],c[0][2],c[0][3],c[1],layer=_user_stacks['drawparams']['l'],thickness=_user_stacks['drawparams']['t']),'Draw',
|
|
|
+ "[STARTX,STARTY,CENTERX,CENTERY DEGREES] Draw an arc with the given parameters. Layer and Thickness are taken from the draw parameters (see params command)"),
|
|
|
+ 'remove':Command(1,lambda c: REMOVE(*c),'Layer',
|
|
|
+ '[OBJECTORLIST] remove items from board. Works with any items in Modules, Tracks, or Drawings.'),
|
|
|
+ 'tosegments':Command(2,lambda c: tosegments(*c),'Layer',
|
|
|
+ '[LIST LAYER] copy tracks or point pairs in LIST to drawpoly on LAYER. Copies width of each track.'),
|
|
|
+ 'drawpoly':Command(1,lambda c: draw_segmentlist(c[0],layer=_user_stacks['drawparams']['l'],thickness=_user_stacks['drawparams']['t']),'Draw',
|
|
|
+ "[POINTSLIST] Points list is interpreted as pairs of X/Y values. Line segments are"
|
|
|
+ "drawn between all successive pairs of points, creating a connected sequence of lines "
|
|
|
+ "where each point is a vertex in a polygon "
|
|
|
+ "as opposed to being just a list of line segments or point pairs. "
|
|
|
+ "This command uses previously set drawparams and the points are in native units (nm) so using mm or mils commands is suggested."),
|
|
|
+ 'drawtext': Command(2,lambda c: draw_text(c[0],c[1],[_user_stacks['drawparams']['w'],_user_stacks['drawparams']['h']],layer=_user_stacks['drawparams']['l'],thickness=_user_stacks['drawparams']['t']),'Draw',
|
|
|
+ '[TEXT POSITION] Draws the TEXT at POSITION using previously set drawparams. Position is in native units (nm) so using mm or mils commands is suggested.'),
|
|
|
+ 'drawparams': Command(2,lambda c: DRAWPARAMS(c),'Draw',
|
|
|
+ '[THICKNESS,WIDTH,HEIGHT LAYER] Set drawing parameters for future draw commands.\n'
|
|
|
+ 'Example: 1,5,5 mm F.Fab drawparams'),
|
|
|
+ 'showparam': Command(0,lambda c: _user_stacks['drawparams'],'Draw',
|
|
|
+ 'Return the draw parameters.'),
|
|
|
+ 'findnet': Command(1,lambda c: FINDNET(*c),'Draw','[NETNAME] Returns the netcode of NETNAME.'),
|
|
|
+ 'param': Command(2,lambda c: PARAM(*c),'Draw',
|
|
|
+ '[VALUESLIST KEYLIST] Set drawing parameters. Each member of VALUELIST is assigned to the '
|
|
|
+ 'corresponding key in KEYLIST. Keys are "t,w,h,l,zt,zp" indicating Thickness, Width, Height, '
|
|
|
+ 'Layer, ZoneType, ZonePriority. ZoneType is one of NO_HATCH, DIAGONAL_FULL, or DIAGONAL_EDGE.\n'
|
|
|
+ 'Example: 1,5,5 mm t,w,h param'),
|
|
|
+ 'helpall': Command(0,lambda c: HELPALL(),'Help',
|
|
|
+ "Shows detailed help on every command."),
|
|
|
+ 'help': Command(0,lambda c: HELPMAIN(),'Help',
|
|
|
+ "Shows general help"),
|
|
|
+ 'explain': Command(1,lambda c: EXPLAIN(*c),'Help',
|
|
|
+ "[COMMAND] Shows help for COMMAND. COMMAND can be a comma separated list of commands (use a comma after a single command to prevent KiCommand from interpreting the command). The keyword 'All' shows help for all commands. You can precede the COMMAND by single quote mark so that it does not execute, or use the comma trick."),
|
|
|
+
|
|
|
+
|
|
|
+ 'helpcat': Command(1,lambda c: HELPCAT(*c),'Help',
|
|
|
+ "[CATEGORY] Shows commands in CATEGORY. CATEGORY value of 'All' shows all categories."),
|
|
|
+ 'pad2draw': Command(1,lambda c: pad_to_drawsegment(*c),'Draw',
|
|
|
+ '[PADLIST] draws outlines around pad on DRAWPARAMS layer.'),
|
|
|
+ 'load': Command(1,lambda c: LOAD(*c),'Programming',
|
|
|
+ '[FILENAME] executes commands from FILENAME. relative to '
|
|
|
+ '~/kicad/kicommand then $KICOMMAND_MODULE_DIR/loadable. Note that this command is not '
|
|
|
+ 'totally symmetric with the save command.'),
|
|
|
+ 'save': Command(1,lambda c: SAVE(*c),'Programming',
|
|
|
+ '[FILENAME] saves the user dictionary into FILENAME relative to '
|
|
|
+ '~/kicad/kicommand. Note that this command is not '
|
|
|
+ 'totally symmetric with the load command.'),
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+})
|
|
|
+
|
|
|
+_newcommanddictionary = None
|
|
|
+_compile_mode = False
|
|
|
+def setcompilemode(val=True, dictionary='user'):
|
|
|
+ global _compile_mode
|
|
|
+ global _newcommanddictionary
|
|
|
+ _newcommanddictionary = dictionary
|
|
|
+ _compile_mode=val
|
|
|
+
|
|
|
+"""Tracks whether compile mode is on, allowing new command definitions.
|
|
|
+ This is affected by the commands : and ;"""
|
|
|
+_command_definition = []
|
|
|
+_user_dictionary = _dictionary['user']
|
|
|
+
|
|
|
+_user_stacks = defaultdict(list)
|
|
|
+
|
|
|
+_user_stacks['drawparams'] = {
|
|
|
+ 't':0.3*pcbnew.IU_PER_MM,
|
|
|
+ 'w':1*pcbnew.IU_PER_MM,
|
|
|
+ 'h':1*pcbnew.IU_PER_MM,
|
|
|
+ 'l':pcbnew.Dwgs_User,
|
|
|
+ 'zt':pcbnew.CPolyLine.NO_HATCH,
|
|
|
+ 'zp':0
|
|
|
+ }
|
|
|
+
|
|
|
+_user_stacks['Board'].append(pcbnew.GetBoard())
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def print_userdict(command=None):
|
|
|
+ for dictname in ['user','persist']:
|
|
|
+ output( '\n',dictname,'Dictionary')
|
|
|
+ if command:
|
|
|
+ commands = filter (lambda x:x[0].startswith(command),_dictionary[dictname].iteritems())
|
|
|
+ else:
|
|
|
+ commands = _dictionary[dictname].iteritems()
|
|
|
+
|
|
|
+ for found,definition in sorted(commands,key=lambda x:x[0]):
|
|
|
+ text = _dictionary[dictname][found]
|
|
|
+ if hasattr(text,'helptext'):
|
|
|
+ text = '"'+text.category+' '+text.helptext+'" '+' '.join(text.execute)
|
|
|
+ output( ":",found,text,';')
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+def printcategories():
|
|
|
+ result=defaultdict(set)
|
|
|
+ for key,val in _command_dictionary.iteritems():
|
|
|
+ result[val.category].add(key)
|
|
|
+
|
|
|
+ for key,val in result.iteritems():
|
|
|
+ output( key)
|
|
|
+ output( '\t','\n\t'.join(val))
|
|
|
+
|
|
|
+pshapesactual = filter(lambda x: x.startswith('PAD_SHAPE_'),dir(pcbnew))
|
|
|
+pshapes = ['PAD_SHAPE_CIRCLE','PAD_SHAPE_OVAL', 'PAD_SHAPE_RECT', 'PAD_SHAPE_ROUNDRECT', 'PAD_SHAPE_TRAPEZOID']
|
|
|
+
|
|
|
+if Counter(pshapesactual) != Counter(pshapes):
|
|
|
+ try:
|
|
|
+ output( 'Warning! Expected Pad Shapes are different than KiCommand expects.')
|
|
|
+ except:
|
|
|
+ pass
|
|
|
+
|
|
|
+
|
|
|
+def pad_to_drawsegment(pad):
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ pshape2ds = {
|
|
|
+ pcbnew.PAD_SHAPE_CIRCLE:pcbnew.S_CIRCLE,
|
|
|
+ pcbnew.PAD_SHAPE_RECT:pcbnew.S_RECT,
|
|
|
+ pcbnew.PAD_SHAPE_ROUNDRECT:pcbnew.S_RECT,
|
|
|
+ pcbnew.PAD_SHAPE_OVAL:pcbnew.S_RECT,
|
|
|
+ pcbnew.PAD_SHAPE_TRAPEZOID:pcbnew.S_RECT,
|
|
|
+ }
|
|
|
+ board = _user_stacks['Board'][-1]
|
|
|
+ ds=pcbnew.DRAWSEGMENT(board)
|
|
|
+ board.Add(ds)
|
|
|
+ layer = _user_stacks['drawparams']['l']
|
|
|
+ try:
|
|
|
+ layerID = int(layer)
|
|
|
+ except:
|
|
|
+ layerID = _user_stacks['Board'][-1].GetLayerID(str(layer))
|
|
|
+
|
|
|
+ ds.SetLayer(layerID)
|
|
|
+ ds.SetWidth(max(1,int(_user_stacks['drawparams']['t'])))
|
|
|
+
|
|
|
+ if pad.GetShape() in [pcbnew.PAD_SHAPE_RECT,
|
|
|
+ pcbnew.PAD_SHAPE_ROUNDRECT,
|
|
|
+ pcbnew.PAD_SHAPE_OVAL,
|
|
|
+ pcbnew.PAD_SHAPE_TRAPEZOID]:
|
|
|
+ pad.GetBoundingBox()
|
|
|
+ elif pad.GetShape==pcbnew.PAD_SHAPE_CIRCLE:
|
|
|
+ ds.SetShape(S_CIRCLE)
|
|
|
+ ds.SetRadius(pad.GetSize())
|
|
|
+ ds.SetPosition(pad.GetPosition())
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ return ds
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
