version 1.0 updates

Author: soukupak

src/unicorn.inx

@@ -49,18 +49,18 @@ Note: Double-check the orientation of your axes when changing these values!</_pa
 - All text must be converted to paths.
 - Curves are approximated with line segments.
 
-More Info: http://github.com/martymcguire/inkscape-unicorn/</_param>
+More Info: https://github.com/soukupak/inkscape-unicorn-for-marlin</_param>
     </page>
   </param>
 
   <output>
     <extension>.gcode</extension>
     <mimetype>application/x-gcode</mimetype>
-    <_filetypename>MakerBot Unicorn G-Code (*.gcode)</_filetypename>
-    <_filetypetooltip>Toolpath for the MakerBot Unicorn Pen Plotter</_filetypetooltip>
+    <_filetypename>Marlin G-Code (*.gcode)</_filetypename>
+    <_filetypetooltip>Toolpath for marlin based pen plotter</_filetypetooltip>
     <dataloss>true</dataloss>
   </output>
   <script>
-    <command reldir="extensions" interpreter="python">unicorn.py</command>
+    <command location="inx" interpreter="python">unicorn.py</command>
   </script>
 </inkscape-extension>

src/unicorn.py

@@ -23,70 +23,53 @@
 from unicorn.context import GCodeContext
 from unicorn.svg_parser import SvgParser
 
+#self.arg_parser.add_argument
+
 class MyEffect(inkex.Effect):
   def __init__(self):
     inkex.Effect.__init__(self)
-    self.OptionParser.add_option("--pen-up-angle",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--pen-up-angle", type=float,
                       dest="pen_up_angle", default="50.0",
                       help="Pen Up Angle")
-    self.OptionParser.add_option("--pen-down-angle",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--pen-down-angle", type=float,
                       dest="pen_down_angle", default="30.0",
                       help="Pen Down Angle")
-    self.OptionParser.add_option("--start-delay",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--start-delay", type=float,
                       dest="start_delay", default="150.0",
                       help="Delay after pen down command before movement in milliseconds")
-    self.OptionParser.add_option("--stop-delay",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--stop-delay", type=float,
                       dest="stop_delay", default="150.0",
                       help="Delay after pen up command before movement in milliseconds")
-    self.OptionParser.add_option("--xy-feedrate",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--xy-feedrate", type=float,
                       dest="xy_feedrate", default="3500.0",
                       help="XY axes feedrate in mm/min")
-    self.OptionParser.add_option("--z-feedrate",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--z-feedrate", type=float,
                       dest="z_feedrate", default="150.0",
                       help="Z axis feedrate in mm/min")
-    self.OptionParser.add_option("--z-height",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--z-height", type=float,
                       dest="z_height", default="0.0",
                       help="Z axis print height in mm")
-    self.OptionParser.add_option("--finished-height",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--finished-height", type=float,
                       dest="finished_height", default="0.0",
                       help="Z axis height after printing in mm")
-    self.OptionParser.add_option("--register-pen",
-                      action="store", type="string",
+    self.arg_parser.add_argument("--register-pen", type=str,
                       dest="register_pen", default="true",
                       help="Add pen registration check(s)")
-    self.OptionParser.add_option("--x-home",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--x-home", type=float,
                       dest="x_home", default="0.0",
                       help="Starting X position")
-    self.OptionParser.add_option("--y-home",
-                      action="store", type="float",
+    self.arg_parser.add_argument("--y-home", type=float,
                       dest="y_home", default="0.0",
                       help="Starting Y position")
-    self.OptionParser.add_option("--num-copies",
-                      action="store", type="int",
+    self.arg_parser.add_argument("--num-copies", type=int,
                       dest="num_copies", default="1")
-    self.OptionParser.add_option("--continuous",
-                      action="store", type="string",
+    self.arg_parser.add_argument("--continuous", type=str,
                       dest="continuous", default="false",
                       help="Plot continuously until stopped.")
-    self.OptionParser.add_option("--pause-on-layer-change",
-                      action="store", type="string",
+    self.arg_parser.add_argument("--pause-on-layer-change", type=str,
                       dest="pause_on_layer_change", default="false",
                       help="Pause on layer changes.")
-    self.OptionParser.add_option("--tab",
-                      action="store", type="string",
-                      dest="tab")
-
-  def output(self):
-    self.context.generate()
+    self.arg_parser.add_argument("--tab", type=str, dest="tab")
 
   def effect(self):
     self.context = GCodeContext(self.options.xy_feedrate, self.options.z_feedrate, 
@@ -97,12 +80,20 @@ def effect(self):
                            self.options.register_pen,
                            self.options.num_copies,
                            self.options.continuous,
-                           self.svg_file)
+                           self.options.input_file)
     parser = SvgParser(self.document.getroot(), self.options.pause_on_layer_change)
     parser.parse()
     for entity in parser.entities:
       entity.get_gcode(self.context)
+    
+    self.context.generate()
+    MyEffect.save_raw(self, self.context.generate())
+
+    #self.save_raw(self, self.context.generate())
+
+  # def output(self):
+  #   self.context.generate()
+
 
 if __name__ == '__main__':   #pragma: no cover
-  e = MyEffect()
-  e.affect()
+  MyEffect().run()

src/unicorn/context.py

@@ -106,14 +106,14 @@ def generate(self):
         codesets.append(self.loop_forever)
         for codeset in codesets:
           for line in codeset:
-            print line
+            print(line)
       else:
         for p in range(0,self.num_pages):
           for codeset in codesets:
             for line in codeset:
-              print line
+              print(line)
           for line in self.postscript:
-            print line
+            print(line)
 
     def start(self):
       self.codes.append("M400 (finish all movement)")

src/unicorn/entities.py

@@ -1,7 +1,12 @@
 from math import cos, sin, radians
 import pprint
+import warnings
 
 class Entity:
+	def __getattr__(self, name):
+		''' will only get called for undefined attributes '''
+		warnings.warn('No member "%s" contained in settings config.' % name)
+		return ''
 	def get_gcode(self,context):
 		#raise NotImplementedError()
 		return "NIE"
@@ -86,4 +91,3 @@ def get_gcode(self,context):
 					context.last = point
 				context.stop()
 				context.codes.append("")
-

src/unicorn/svg_parser.py

@@ -1,7 +1,8 @@
-import inkex, cubicsuperpath, simplepath, simplestyle, cspsubdiv
+import inkex
 from simpletransform import *
 from bezmisc import *
-import entities
+from lxml import etree
+import unicorn.entities as entities
 from math import radians
 import sys, pprint
 
@@ -51,12 +52,12 @@ def subdivideCubicPath( sp, flat, i=1 ):
 
       b = ( p0, p1, p2, p3 )
 
-      if cspsubdiv.maxdist( b ) > flat:
+      if inkex.bezier.maxdist(b) > flat:
         break
 
       i += 1
 
-    one, two = beziersplitatt( b, 0.5 )
+    one, two = inkex.bezier.beziersplitatt( b, 0.5 )
     sp[i - 1][2] = one[1]
     sp[i][0] = two[2]
     p = [one[2], one[3], two[1]]
@@ -75,23 +76,25 @@ def get_gcode(self,context):
 class SvgPath(entities.PolyLine):
   def load(self, node, mat):
     d = node.get('d')
-    if len(simplepath.parsePath(d)) == 0:
+
+    if(len(d) == 0):
       return
-    p = cubicsuperpath.parsePath(d)
-    applyTransformToPath(mat, p)
+
+    p = inkex.Path.to_superpath(d)
+    p_transformed = p.transform(mat)
 
     # p is now a list of lists of cubic beziers [ctrl p1, ctrl p2, endpoint]
     # where the start-point is the last point in the previous segment
     self.segments = []
-    for sp in p:
+    for sp in p_transformed:
       points = []
       subdivideCubicPath(sp,0.2)  # TODO: smoothness preference
       for csp in sp:
         points.append((csp[1][0],csp[1][1]))
       self.segments.append(points)
 
   def new_path_from_node(self, node):
-    newpath = inkex.etree.Element(inkex.addNS('path','svg'))
+    newpath = etree.Element(inkex.addNS('path','svg'))
     s = node.get('style')
     if s:
       newpath.set('style',s)
@@ -113,7 +116,7 @@ def load(self, node, mat):
     a.append([' l ', [0,h]])
     a.append([' l ', [-w,0]])
     a.append([' Z', []])
-    newpath.set('d', simplepath.formatPath(a))
+    newpath.set('d', formatPath(a))
     SvgPath.load(self,newpath,mat)
 
 class SvgLine(SvgPath):
@@ -126,7 +129,7 @@ def load(self, node, mat):
     a = []
     a.append(['M ', [x1,y1]])
     a.append([' L ', [x2,y2]])
-    newpath.set('d', simplepath.formatPath(a))
+    newpath.set('d', formatPath(a))
     SvgPath.load(self,newpath,mat)
 
 class SvgPolyLine(SvgPath):
@@ -264,7 +267,8 @@ def recursivelyTraverseSvg(self, nodeList,
         pass
 
       # first apply the current matrix transform to this node's transform
-      matNew = composeTransform(matCurrent, parseTransform(node.get("transform")))
+      # matNew = composeTransform(matCurrent, parseTransform(node.get("transform")))
+      matNew = inkex.Transform(matCurrent) * inkex.Transform(node.get("transform"))
 
       if node.tag == inkex.addNS('g','svg') or node.tag == 'g':
         if (node.get(inkex.addNS('groupmode','inkscape')) == 'layer'):
@@ -283,7 +287,7 @@ def recursivelyTraverseSvg(self, nodeList,
             y = float(node.get('y','0'))
             # Note: the transform has already been applied
             if (x!=0) or (y!=0):
-              matNew2 = composeTransform(matNew,parseTransform('translate(%f,%f)' % (x,y)))
+              matNew2 = inkex.Transform(matNew) * inkex.Transform.add_translate(x,y)
             else:
               matNew2 = matNew
             v = node.get('visibility',v)
@@ -292,7 +296,7 @@ def recursivelyTraverseSvg(self, nodeList,
             pass
         else:
           pass
-      elif not isinstance(node.tag, basestring):
+      elif not isinstance(node.tag, str):
         pass
       else:
         entity = self.make_entity(node, matNew)
@@ -313,3 +317,7 @@ def make_entity(self,node,mat):
         self.entities.append(entity)
         return entity
     return None
+
+def formatPath(a):
+    """Format SVG path data from an array"""
+    return "".join([cmd + " ".join([str(p) for p in params]) for cmd, params in a])