From 13b8d3d2340c14453fbf7a1da00420c01779e760 Mon Sep 17 00:00:00 2001
From: Romain Testuz <romain.testuz@rayform.ch>
Date: Sun, 26 Nov 2017 09:00:26 +0100
Subject: [PATCH 1/5] improves the greedy algorithm by allowing paths to be
 reversed (some path commands like A are not supported), it now handles groups
 by considering them as a single path so it will not modify the order inside
 of the group and at the moment, it cannot reverse a group

---
 inkscape_driver/eggbot_reorder.inx |  26 ++--
 inkscape_driver/eggbot_reorder.py  | 217 ++++++++++++++++++++---------
 2 files changed, 166 insertions(+), 77 deletions(-)

diff --git a/inkscape_driver/eggbot_reorder.inx b/inkscape_driver/eggbot_reorder.inx
index fb89fae3..a5273901 100755
--- a/inkscape_driver/eggbot_reorder.inx
+++ b/inkscape_driver/eggbot_reorder.inx
@@ -6,27 +6,27 @@
   <dependency type="executable" location="extensions">eggbot_reorder.py</dependency>
   <dependency type="executable" location="extensions">inkex.py</dependency>
   <!-- Written by Matthew Beckler for the Egg-Bot project. Email questions and comments to matthew at mbeckler dot org -->
-
-	  <_param name="Header" type="description" xml:space="preserve">
- This extension will perform simple optimizations 
- of selected paths. It will try to change the 
+  <_param name="Header" type="description" xml:space="preserve">
+ This extension will perform simple optimizations
+ of selected paths. It will try to change the
  order of plotting so as to reduce the amount
  of "pen-up" travel that occurs between paths.
- 
+
  Solving for optimal plot order is a difficult
  problem, known in computer science as the
- "traveling salesman problem," or just "TSP."  
- 
+ "traveling salesman problem," or just "TSP".
+
  This routine does not look for the best possible
  solution; that can be slow. Instead it tries a
- few quick methods that often reduce pen-up 
- travel distance (and time) by 30% or more. 
+ few quick methods that often reduce pen-up
+ travel distance (and time) by 30% or more.
 
- Please note: This extension is still considered 
- experimental, and is only provided in case you 
- may find it useful. Be sure to save a copy of 
+ Please note: This extension is still considered
+ experimental, and is only provided in case you
+ may find it useful. Be sure to save a copy of
  your document before running this routine.
-            </_param>
+  </_param>
+  <param name="allowReverse" type="boolean" _gui-text="Allow Reverse">true</param>
 
   <!--
   <param name="reverse" type="boolean" _gui-text="Allow paths to be reversed*">false</param>
diff --git a/inkscape_driver/eggbot_reorder.py b/inkscape_driver/eggbot_reorder.py
index 9d0df4c7..b76b32b3 100755
--- a/inkscape_driver/eggbot_reorder.py
+++ b/inkscape_driver/eggbot_reorder.py
@@ -1,9 +1,11 @@
+# coding: utf-8
 # EggBot Path Ordering extension
 # This extension tries to re-order the document's paths to improve
 # the plotting time by plotting nearby paths consecutively.
 #
 # Written by Matthew Beckler for the EggBot project.
 # Email questions and comments to matthew at mbeckler dot org
+# Modified by Romain Testuz
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -30,60 +32,61 @@
 def dist( x0, y0, x1, y1 ):
 	return math.sqrt( ( x1 - x0 ) ** 2 + ( y1 - y0 ) ** 2 )
 
-def find_ordering_naive( objlist ):
+def find_ordering( objlist, allowReverse ):
 	"""
 	Takes a list of (id, (startX, startY, endX, endY)), and finds the best ordering.
-	Doesn't handle anything fancy, like reversing the ordering, but it's useful for now.
-	Returns a list of JUST THE IDs, in a better order, as well as the original and optimized
-	"air distance" which is just the distance traveled in the air. Perhaps we want to make
-	these comparison distances into something more relevant such as degrees traveled?
+	Uses a greedy algorithm which can reverse the path direction if necessary
+	Returns a list of (id, reverse), as well as the original and optimized
+	"air distance" which is just the distance traveled in the air. Reverse indicate if the path must be reversed
 	"""
 
-	# let's figure out the default in-air length, so we know how much we improved
+	startX, startY = 0.0, 0.0 #Start point TODO 0,0 is not top left of the page
+
+	# let's figure out the default in-air length (this is not meaningful as we are using the dictionary ordering)
 	air_length_default = 0
-	try:
-		oldx = objlist[0][1][2]
-		oldy = objlist[0][1][3]
-	except:
-		inkex.errormsg( gettext.gettext( str( objlist[0] ) ) )
-		sys.exit( 1 )
-	for id, coords in objlist[1:]:
+	oldx, oldy = startX, startY
+
+	for id, coords in objlist:
+		#inkex.debug(( id, oldx, oldy, coords[0], coords[1] ))
 		air_length_default += dist( oldx, oldy, coords[0], coords[1] )
 		oldx = coords[2]
 		oldy = coords[3]
 	#fid.write("Default air distance: %d\n" % air_length_default)
 
 	air_length_ordered = 0
-	# for now, start with a random one:
+
 	sort_list = []
-	random_index = random.randint( 0, len( objlist ) - 1 )
-	sort_list.append( objlist[random_index] )
-	objlist.remove( objlist[random_index] )
+	prevX, prevY = startX, startY
 
-	# for now, do this in the most naive way:
-	# for the previous end point, iterate over each remaining path and pick the closest starting point
+	# for the previous end point, iterate over each remaining path and pick the closest starting point or ending point if allowed
 	while len( objlist ) > 0:
-		min_distance = 100000000 # TODO put something else here better?
+		min_distance = sys.float_info.max #The biggest number possible
 		for path in objlist:
-			# instead of having a prevX, prevY, we just look at the last item in sort_list
-			this_distance = dist( sort_list[-1][1][2], sort_list[-1][1][3], path[1][0], path[1][1] )
-			# this is such a common thing to do, you'd think there would be a name for it...
-			if this_distance < min_distance:
-				min_distance = this_distance
+			dist_to_start = dist( prevX, prevY, path[1][0], path[1][1] )
+			dist_to_end = dist( prevX, prevY, path[1][2], path[1][3] ) if allowReverse else -1
+
+			if dist_to_start < min_distance:
+				min_distance = dist_to_start
 				min_path = path
+				reverse = False
+
+			if allowReverse and dist_to_end < min_distance:
+				min_distance = dist_to_end
+				min_path = path
+				reverse = True
+
 		air_length_ordered += min_distance
-		sort_list.append( min_path )
+		sort_list.append( (min_path[0], reverse) ) #Add (id, reverse)
 		objlist.remove( min_path )
+		(prevX, prevY) = (min_path[1][0], min_path[1][1]) if reverse else (min_path[1][2], min_path[1][3])
 
 	#fid.write("optimized air distance: %d\n" % air_length_ordered)
 
-	# remove the extraneous info from the list order
-	sort_order = [id for id, coords in sort_list]
-	return sort_order, air_length_default, air_length_ordered
+	return sort_list, air_length_default, air_length_ordered
 
 def conv( x, y, trans_matrix=None ):
 	"""
-	not used currently, but can be used to apply a translation matrix to an (x, y) pair
+	apply a translation matrix to an (x, y) pair
 	I'm sure there is a better way to do this using simpletransform or it's ilk
 	"""
 
@@ -94,33 +97,109 @@ def conv( x, y, trans_matrix=None ):
 	else:
 		return x, y
 
+def reversePath( path ):
+	#Input: path in simplepath format
+	#Returns the reversed path in a svg string format
+	#In case of error the path is returned unchanged
+	#Some commands like A, H, V are not supported
+	#Adapted from https://github.com/Pomax/svg-path-reverse/blob/gh-pages/reverse.js
+
+	#Unpack sublists into a single list
+	flattenedPath = [item for sublist in path for subsublist in sublist for item in subsublist]#Sorry
+	reversedPath = []
+
+	i = 0
+	while i < len(flattenedPath):
+		term = flattenedPath[i]
+		#At this point the next term must be a letter because the coordinates must have all been read
+		if term == "C":
+			pairs = 3; shift = 2
+		elif term == "Q":
+			pairs = 2; shift = 1
+		elif term == "L":
+			pairs = 1; shift = 1
+		elif term == "M":
+			pairs = 1; shift = 0
+		elif term == "Z":
+			reversedPath[0] = "Z"; i += 1; continue
+		else:
+			inkex.errormsg("Cannot reverse path, unknown command: {} or malformed path: {}".format(term, flattenedPath))
+			return ' '.join(str(e) for e in flattenedPath)#to string
+
+		if pairs == shift:
+			reversedPath.append(term)
+
+		for pair in range(0, pairs):
+			if pair == shift:
+				reversedPath.append(term)
+			i += 1
+			x = flattenedPath[i]
+			i += 1
+			y = flattenedPath[i]
+			reversedPath.append(y)
+			reversedPath.append(x)
+		i += 1
+
+	reversedPath.append("M")
+	reversedPath = list(reversed(reversedPath))
+	if reversedPath[-1] == "M":#Only remove the last element if it's not a Z
+		reversedPath = reversedPath[:-1]
+
+	return ' '.join(str(e) for e in reversedPath)#to string
+
 class EggBotReorderPaths( inkex.Effect ):
 	def __init__( self ):
 		inkex.Effect.__init__( self )
-# 		self.OptionParser.add_option( '-r', '--reverse', action='store', type="inkbool",
-# 			dest="reverse", default=True, help="Enable 'reverse path direction' optimizations" )
-# 		self.OptionParser.add_option( '-w', '--wrap', action='store', type="inkbool",
-# 				dest="wrap", default=True, help="Enable 'wrap egg axis' optimizations" )
+		self.OptionParser.add_option("-r", "--allowReverse", action="store", type="inkbool",
+                        dest="allowReverse", default=True, help="Allow path reversal")
 
-	def get_start_end( self, node, transform ):
+	def get_start_end( self, node ):
 		"""Given a node, return the start and end points"""
-		d = node.get( 'd' )
-		sp = simplepath.parsePath( d )
-
-		# simplepath converts coordinates to absolute and cleans them up, but
-		# these are still some big assumptions here, are they always valid? TODO
-		startX = sp[0][1][0]
-		startY = sp[0][1][1]
-		if sp[-1][0] == 'Z':
-			# go back to start
-			endX = startX
-			endY = startY
+		nodeStart = node
+		nodeEnd = node
+		transformStart = simpletransform.parseTransform( node.get( 'transform' ) )
+		transformEnd = transformStart
+
+		while nodeStart.tag == inkex.addNS( 'g', 'svg' ):
+			nodeStart = nodeStart[0]
+			if transformStart:
+				transformStart = simpletransform.parseTransform( nodeStart.get( 'transform' ), transformStart )
+
+		while nodeEnd.tag == inkex.addNS( 'g', 'svg' ):
+			nodeEnd = nodeEnd[-1]
+			if transformEnd:
+				transformEnd = simpletransform.parseTransform( nodeEnd.get( 'transform' ), transformEnd )
+
+		if nodeStart.tag == inkex.addNS( 'path', 'svg' ):
+			d_start = nodeStart.get( 'd' )
+			sp_start = simplepath.parsePath( d_start )
+			# simplepath converts coordinates to absolute and cleans them up, but
+			# these are still some big assumptions here, are they always valid? TODO
+			startX = sp_start[0][1][0]
+			startY = sp_start[0][1][1]
+		else:
+			inkex.errormsg("This script only work with paths and groups, please convert objects to paths")
+			startX = 0.0
+			startY = 0.0
+
+		if nodeEnd.tag == inkex.addNS( 'path', 'svg' ):
+			d_end = nodeEnd.get( 'd' )
+			sp_end = simplepath.parsePath( d_end )
+			if sp_end[-1][0] == 'Z':
+				# go back to start
+				endX = sp_end[0][1][0]
+				endY = sp_end[0][1][1]
+			else:
+				endX = sp_end[-1][1][-2]
+				endY = sp_end[-1][1][-1]
 		else:
-			endX = sp[-1][1][-2]
-			endY = sp[-1][1][-1]
+			inkex.errormsg("This script only work with paths and groups, please convert objects to paths")
+			endX = 0.0
+			endY = 0.0
 
-		sx, sy = conv( startX, startY, transform )
-		ex, ey = conv( endX, endY, transform )
+		sx, sy = conv( startX, startY, transformStart )
+		ex, ey = conv( endX, endY, transformEnd )
+		#inkex.debug(( sx, sy, ex, ey ))
 		return ( sx, sy, ex, ey )
 
 	def effect( self ):
@@ -128,40 +207,50 @@ def effect( self ):
 
 		# based partially on the restack.py extension
 		if len( self.selected ) > 0:
-			svg = self.document.getroot()
-
 			# TODO check for non-path elements?
 			# TODO it seems like the order of selection is not consistent
+			# => self.selected is a dict so it has no meaningful order and should not be used to evaluate the original path length
 
 			#fid = open("/home/matthew/debug.txt", "w")
 
-			# for each selected item - TODO make this be all objects, everywhere
+			# for each selected item
 			# I can think of two options:
 			# 1. Iterate over all paths in root, then iterate over all layers, and their paths
 			# 2. Some magic with xpath? (would this limit us to specific node types?)
 
 			objlist = []
 			for id, node in self.selected.iteritems():
-				transform = node.get( 'transform' )
-				if transform:
-					transform = simpletransform.parseTransform( transform )
-
-				item = ( id, self.get_start_end( node, transform ) )
+				item = ( id, self.get_start_end( node ) )
 				objlist.append( item )
 
 			# sort / order the objects
-			sort_order, air_distance_default, air_distance_ordered = find_ordering_naive( objlist )
+			sort_order, air_distance_default, air_distance_ordered = find_ordering( objlist, self.options.allowReverse )
+
+			reverseCount = 0
+			for id, reverse in sort_order:
+				node = self.selected[id]
+				if node.tag == inkex.addNS( 'path', 'svg' ):
+					node_sp = simplepath.parsePath( node.get( 'd' ) )
+					if(reverse):
+						node_sp_string = reversePath(node_sp)
+						reverseCount += 1
+					else:
+						node_sp_string = simplepath.formatPath(node_sp)
+
+					node.set('d', node_sp_string)
+				elif node.tag == inkex.addNS( 'g', 'svg' ) and reverse:
+						#TODO Every element of the group should be reversed
+						inkex.errormsg("Reversing groups is currently not possible, please ungroup for better results")
 
-			for id in sort_order:
-				# There's some good magic here, that you can use an
-				# object id to index into self.selected. Brilliant!
-				self.current_layer.append( self.selected[id] )
+				#keep in mind the different selected ids might have different parents
+				self.getParentNode( node ).append( node )
 
+			inkex.errormsg("Reversed {} paths.".format(reverseCount))
 			#fid.close()
 
 			if air_distance_default > 0 :  #don't divide by zero. :P
 				improvement_pct = 100 * ( ( air_distance_default - air_distance_ordered ) / ( air_distance_default ) )
-				inkex.errormsg( gettext.gettext( "Selected paths have been reordered and optimized for quicker EggBot plotting.\n\nOriginal air-distance: %d\nOptimized air-distance: %d\nDistance reduced by: %1.2d%%\n\nHave a nice day!" % ( air_distance_default, air_distance_ordered, improvement_pct ) ) )
+				inkex.errormsg( gettext.gettext( "Selected paths have been reordered and optimized for quicker EggBot plotting.\n\nDefault air-distance: %d\nOptimized air-distance: %d\nDistance reduced by: %1.2d%%\n\nHave a nice day!" % ( air_distance_default, air_distance_ordered, improvement_pct ) ) )
 			else:
 				inkex.errormsg( gettext.gettext( "Unable to start. Please select multiple distinct paths. :)" ) )
 

From 62dd25ae42f2fa7d69e4517198cf31dda48e1c34 Mon Sep 17 00:00:00 2001
From: Romain Testuz <romain.testuz@rayform.ch>
Date: Tue, 28 Nov 2017 17:30:06 +0100
Subject: [PATCH 2/5] cleanup old comment

---
 inkscape_driver/eggbot_reorder.inx | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/inkscape_driver/eggbot_reorder.inx b/inkscape_driver/eggbot_reorder.inx
index a5273901..8217eb3a 100755
--- a/inkscape_driver/eggbot_reorder.inx
+++ b/inkscape_driver/eggbot_reorder.inx
@@ -28,14 +28,6 @@
   </_param>
   <param name="allowReverse" type="boolean" _gui-text="Allow Reverse">true</param>
 
-  <!--
-  <param name="reverse" type="boolean" _gui-text="Allow paths to be reversed*">false</param>
-  <param name="wrap" type="boolean" _gui-text="Allow wrap-around egg axis*">false</param>
-
-	  <_param name="nyet" type="description" xml:space="preserve">
-  *Option not yet implemented.
-            </_param>
--->
   <effect needs-live-preview="false" needs-document="no">
     <object-type>all</object-type>
     <effects-menu>

From 951dd084ccb514f78244f085cafb9c2a1222f66a Mon Sep 17 00:00:00 2001
From: Romain Testuz <romain.testuz@rayform.ch>
Date: Sun, 10 Dec 2017 10:31:09 +0100
Subject: [PATCH 3/5] Create Path class

---
 inkscape_driver/eggbot_reorder.py | 74 ++++++++++++++++++++-----------
 1 file changed, 48 insertions(+), 26 deletions(-)

diff --git a/inkscape_driver/eggbot_reorder.py b/inkscape_driver/eggbot_reorder.py
index b76b32b3..5b5b018a 100755
--- a/inkscape_driver/eggbot_reorder.py
+++ b/inkscape_driver/eggbot_reorder.py
@@ -32,55 +32,76 @@
 def dist( x0, y0, x1, y1 ):
 	return math.sqrt( ( x1 - x0 ) ** 2 + ( y1 - y0 ) ** 2 )
 
+def dist_t( x, y ):
+	return dist(x[0], x[1], y[0], y[1])
+
+class Path:
+	def __init__(self, id, start, end, reversed=False):
+		self.id = id
+		self.start = start
+		self.end = end
+		self.reversed = reversed
+
+	def __eq__(self, other): #ids must be unique
+		return self.id == other.id
+
+	def get_start(self):
+		return self.start if not self.reversed else self.end
+
+	def get_end(self):
+		return self.end if not self.reversed else self.start
+
+	def reverse(self):
+		self.reversed = not self.reversed
+
+	def dist_to_start(self, otherPath):
+		return dist_t(self.get_end(), otherPath.get_start())
+
+	def dist_to_end(self, otherPath):
+		return dist_t(self.get_end(), otherPath.get_end())
+
 def find_ordering( objlist, allowReverse ):
 	"""
-	Takes a list of (id, (startX, startY, endX, endY)), and finds the best ordering.
+	Takes a list of Paths, and finds the best ordering.
 	Uses a greedy algorithm which can reverse the path direction if necessary
 	Returns a list of (id, reverse), as well as the original and optimized
 	"air distance" which is just the distance traveled in the air. Reverse indicate if the path must be reversed
 	"""
 
-	startX, startY = 0.0, 0.0 #Start point TODO 0,0 is not top left of the page
+	start = (0.0, 0.0) #Start point TODO 0,0 is not always top left of the page
 
 	# let's figure out the default in-air length (this is not meaningful as we are using the dictionary ordering)
 	air_length_default = 0
-	oldx, oldy = startX, startY
+	old = start
 
-	for id, coords in objlist:
-		#inkex.debug(( id, oldx, oldy, coords[0], coords[1] ))
-		air_length_default += dist( oldx, oldy, coords[0], coords[1] )
-		oldx = coords[2]
-		oldy = coords[3]
-	#fid.write("Default air distance: %d\n" % air_length_default)
+	for i, path in enumerate(objlist[1:]):
+		air_length_default += objlist[i-1].dist_to_start(path)
 
 	air_length_ordered = 0
 
 	sort_list = []
-	prevX, prevY = startX, startY
+	prev = Path(-1, (0,0), (0,0))
 
 	# for the previous end point, iterate over each remaining path and pick the closest starting point or ending point if allowed
 	while len( objlist ) > 0:
 		min_distance = sys.float_info.max #The biggest number possible
 		for path in objlist:
-			dist_to_start = dist( prevX, prevY, path[1][0], path[1][1] )
-			dist_to_end = dist( prevX, prevY, path[1][2], path[1][3] ) if allowReverse else -1
+			dist_to_start = prev.dist_to_start(path)
+			dist_to_end = prev.dist_to_end(path)
 
 			if dist_to_start < min_distance:
 				min_distance = dist_to_start
 				min_path = path
-				reverse = False
 
 			if allowReverse and dist_to_end < min_distance:
 				min_distance = dist_to_end
+				path.reverse()
 				min_path = path
-				reverse = True
 
 		air_length_ordered += min_distance
-		sort_list.append( (min_path[0], reverse) ) #Add (id, reverse)
+		sort_list.append( min_path )
 		objlist.remove( min_path )
-		(prevX, prevY) = (min_path[1][0], min_path[1][1]) if reverse else (min_path[1][2], min_path[1][3])
-
-	#fid.write("optimized air distance: %d\n" % air_length_ordered)
+		prev = min_path
 
 	return sort_list, air_length_default, air_length_ordered
 
@@ -105,7 +126,7 @@ def reversePath( path ):
 	#Adapted from https://github.com/Pomax/svg-path-reverse/blob/gh-pages/reverse.js
 
 	#Unpack sublists into a single list
-	flattenedPath = [item for sublist in path for subsublist in sublist for item in subsublist]#Sorry
+	flattenedPath = [item for sublist in path for subsublist in sublist for item in subsublist]
 	reversedPath = []
 
 	i = 0
@@ -220,30 +241,31 @@ def effect( self ):
 
 			objlist = []
 			for id, node in self.selected.iteritems():
-				item = ( id, self.get_start_end( node ) )
-				objlist.append( item )
+				(sx, sy, ex, ey) = self.get_start_end( node )
+				path = Path( id, (sx, sy), (ex, ey) )
+				objlist.append( path )
 
 			# sort / order the objects
 			sort_order, air_distance_default, air_distance_ordered = find_ordering( objlist, self.options.allowReverse )
 
 			reverseCount = 0
-			for id, reverse in sort_order:
-				node = self.selected[id]
+			for path in sort_order:
+				node = self.selected[path.id]
 				if node.tag == inkex.addNS( 'path', 'svg' ):
 					node_sp = simplepath.parsePath( node.get( 'd' ) )
-					if(reverse):
+					if(path.reversed):
 						node_sp_string = reversePath(node_sp)
 						reverseCount += 1
 					else:
 						node_sp_string = simplepath.formatPath(node_sp)
 
 					node.set('d', node_sp_string)
-				elif node.tag == inkex.addNS( 'g', 'svg' ) and reverse:
+				elif node.tag == inkex.addNS('g', 'svg') and path.reversed:
 						#TODO Every element of the group should be reversed
 						inkex.errormsg("Reversing groups is currently not possible, please ungroup for better results")
 
 				#keep in mind the different selected ids might have different parents
-				self.getParentNode( node ).append( node )
+				self.getParentNode(node).append(node)
 
 			inkex.errormsg("Reversed {} paths.".format(reverseCount))
 			#fid.close()

From bf8104b4f42caa6796b5a3cf8d8942344f0f628a Mon Sep 17 00:00:00 2001
From: Romain Testuz <romain.testuz@rayform.ch>
Date: Sun, 10 Dec 2017 10:48:05 +0100
Subject: [PATCH 4/5] removed group support

---
 inkscape_driver/eggbot_reorder.py | 69 +++++++++++--------------------
 1 file changed, 23 insertions(+), 46 deletions(-)

diff --git a/inkscape_driver/eggbot_reorder.py b/inkscape_driver/eggbot_reorder.py
index 5b5b018a..2068de2e 100755
--- a/inkscape_driver/eggbot_reorder.py
+++ b/inkscape_driver/eggbot_reorder.py
@@ -176,51 +176,31 @@ def __init__( self ):
 
 	def get_start_end( self, node ):
 		"""Given a node, return the start and end points"""
-		nodeStart = node
-		nodeEnd = node
-		transformStart = simpletransform.parseTransform( node.get( 'transform' ) )
-		transformEnd = transformStart
-
-		while nodeStart.tag == inkex.addNS( 'g', 'svg' ):
-			nodeStart = nodeStart[0]
-			if transformStart:
-				transformStart = simpletransform.parseTransform( nodeStart.get( 'transform' ), transformStart )
-
-		while nodeEnd.tag == inkex.addNS( 'g', 'svg' ):
-			nodeEnd = nodeEnd[-1]
-			if transformEnd:
-				transformEnd = simpletransform.parseTransform( nodeEnd.get( 'transform' ), transformEnd )
-
-		if nodeStart.tag == inkex.addNS( 'path', 'svg' ):
-			d_start = nodeStart.get( 'd' )
-			sp_start = simplepath.parsePath( d_start )
-			# simplepath converts coordinates to absolute and cleans them up, but
-			# these are still some big assumptions here, are they always valid? TODO
-			startX = sp_start[0][1][0]
-			startY = sp_start[0][1][1]
+		if node.tag != inkex.addNS( 'path', 'svg' ):
+			inkex.errormsg("Groups are not supported, please ungroup for better results")
+			return (0, 0, 0, 0)
+
+		d = node.get( 'd' )
+		sp = simplepath.parsePath( d )
+
+		# simplepath converts coordinates to absolute and cleans them up, but
+		# these are still some big assumptions here, are they always valid? TODO
+		startX = sp[0][1][0]
+		startY = sp[0][1][1]
+		if sp[-1][0] == 'Z':
+			# go back to start
+			endX = startX
+			endY = startY
 		else:
-			inkex.errormsg("This script only work with paths and groups, please convert objects to paths")
-			startX = 0.0
-			startY = 0.0
-
-		if nodeEnd.tag == inkex.addNS( 'path', 'svg' ):
-			d_end = nodeEnd.get( 'd' )
-			sp_end = simplepath.parsePath( d_end )
-			if sp_end[-1][0] == 'Z':
-				# go back to start
-				endX = sp_end[0][1][0]
-				endY = sp_end[0][1][1]
-			else:
-				endX = sp_end[-1][1][-2]
-				endY = sp_end[-1][1][-1]
-		else:
-			inkex.errormsg("This script only work with paths and groups, please convert objects to paths")
-			endX = 0.0
-			endY = 0.0
+			endX = sp[-1][1][-2]
+			endY = sp[-1][1][-1]
+
+		transform = node.get( 'transform' )
+		if transform:
+			transform = simpletransform.parseTransform( transform )
 
-		sx, sy = conv( startX, startY, transformStart )
-		ex, ey = conv( endX, endY, transformEnd )
-		#inkex.debug(( sx, sy, ex, ey ))
+		sx, sy = conv( startX, startY, transform )
+		ex, ey = conv( endX, endY, transform )
 		return ( sx, sy, ex, ey )
 
 	def effect( self ):
@@ -260,9 +240,6 @@ def effect( self ):
 						node_sp_string = simplepath.formatPath(node_sp)
 
 					node.set('d', node_sp_string)
-				elif node.tag == inkex.addNS('g', 'svg') and path.reversed:
-						#TODO Every element of the group should be reversed
-						inkex.errormsg("Reversing groups is currently not possible, please ungroup for better results")
 
 				#keep in mind the different selected ids might have different parents
 				self.getParentNode(node).append(node)

From 34f1ffbf899ed3cb447524f9b6a32a5c6f2b4b1c Mon Sep 17 00:00:00 2001
From: Romain Testuz <romain.testuz@rayform.ch>
Date: Sun, 10 Dec 2017 18:24:41 +0100
Subject: [PATCH 5/5] renamed Path attributes to be safer

---
 inkscape_driver/eggbot_reorder.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/inkscape_driver/eggbot_reorder.py b/inkscape_driver/eggbot_reorder.py
index 2068de2e..d0a4f345 100755
--- a/inkscape_driver/eggbot_reorder.py
+++ b/inkscape_driver/eggbot_reorder.py
@@ -36,20 +36,23 @@ def dist_t( x, y ):
 	return dist(x[0], x[1], y[0], y[1])
 
 class Path:
-	def __init__(self, id, start, end, reversed=False):
+	def __init__(self, id, p1, p2, reversed=False):
 		self.id = id
-		self.start = start
-		self.end = end
+		self.p1 = p1
+		self.p2 = p2
 		self.reversed = reversed
 
 	def __eq__(self, other): #ids must be unique
 		return self.id == other.id
 
+	def __str__(self):
+		return "{}: {} {}".format(self.id, self.get_start(), self.get_end())
+
 	def get_start(self):
-		return self.start if not self.reversed else self.end
+		return self.p1 if not self.reversed else self.p2
 
 	def get_end(self):
-		return self.end if not self.reversed else self.start
+		return self.p2 if not self.reversed else self.p1
 
 	def reverse(self):
 		self.reversed = not self.reversed
@@ -80,7 +83,7 @@ def find_ordering( objlist, allowReverse ):
 	air_length_ordered = 0
 
 	sort_list = []
-	prev = Path(-1, (0,0), (0,0))
+	prev = Path("", start, start)
 
 	# for the previous end point, iterate over each remaining path and pick the closest starting point or ending point if allowed
 	while len( objlist ) > 0: