Merge pull request #8 from soukupak/add_sorting

Add entity sorting for less travel

Author: soukupak

src/py2opt/__init__.py

@@ -0,0 +1,65 @@
+import random
+import time
+
+from py2opt.solver import Solver
+
+
+class RouteFinder:
+    def __init__(self, distance_matrix, cities_names, iterations=5, writer_flag=False, method='py2opt', return_to_begin=False, verbose=True):
+        self.distance_matrix = distance_matrix
+        self.iterations = iterations
+        self.return_to_begin = return_to_begin
+        self.writer_flag = writer_flag
+        self.cities_names = cities_names
+        self.verbose = verbose
+
+    def solve(self):
+        start_time = round(time.time() * 1000)
+        elapsed_time = 0
+        iteration = 0
+        best_distance = 0
+        best_route = []
+        best_distances = []
+
+        while iteration < self.iterations:
+            num_cities = len(self.distance_matrix)
+            if self.verbose:
+                print(round(elapsed_time), 'msec')
+            initial_route = [0] + random.sample(range(1, num_cities), num_cities - 1)
+            if self.return_to_begin:
+                initial_route.append(0)
+            tsp = Solver(self.distance_matrix, initial_route)
+            new_route, new_distance, distances = tsp.two_opt()
+
+            if iteration == 0:
+                best_distance = new_distance
+                best_route = new_route
+            else:
+                pass
+
+            if new_distance < best_distance:
+                best_distance = new_distance
+                best_route = new_route
+                best_distances = distances
+
+            elapsed_time = round(time.time() * 1000) - start_time
+            iteration += 1
+
+        if self.writer_flag:
+            self.writer(best_route, best_distance, self.cities_names)
+
+        if self.cities_names:
+            best_route = [self.cities_names[i] for i in best_route]
+            return best_distance, best_route
+        else:
+            return best_distance, best_route
+
+    @staticmethod
+    def writer(best_route, best_distance, cities_names):
+        f = open("../results.txt", "w+")
+        for i in best_route:
+            f.write(cities_names[i])
+            f.write("\n")
+            print(cities_names[i])
+        f.write(str(best_distance))
+        f.close()

src/py2opt/routefinder.py

@@ -0,0 +1,70 @@
+import itertools
+import numpy as np
+
+
+class Solver:
+    def __init__(self, distance_matrix, initial_route):
+        self.distance_matrix = distance_matrix
+        self.num_cities = len(self.distance_matrix)
+        self.initial_route = initial_route
+        self.best_route = []
+        self.best_distance = 0
+        self.distances = []
+
+    def update(self, new_route, new_distance):
+        self.best_distance = new_distance
+        self.best_route = new_route
+        return self.best_distance, self.best_route
+
+    def exhaustive_search(self):
+        self.best_route = [0] + list(range(1, self.num_cities))
+        self.best_distance = self.calculate_path_dist(self.distance_matrix, self.best_route)
+
+        for new_route in itertools.permutations(list(range(1, self.num_cities))):
+            new_distance = self.calculate_path_dist(self.distance_matrix, [0] + list(new_route[:]))
+
+            if new_distance < self.best_distance:
+                self.update([0] + list(new_route[:]), new_distance)
+                self.distances.append(self.best_distance)
+
+        return self.best_route, self.best_distance, self.distances
+
+    def two_opt(self, improvement_threshold=0.01):
+        self.best_route = self.initial_route
+        self.best_distance = self.calculate_path_dist(self.distance_matrix, self.best_route)
+        improvement_factor = 1
+        
+        while improvement_factor > improvement_threshold:
+            previous_best = self.best_distance
+            for swap_first in range(1, self.num_cities - 2):
+                for swap_last in range(swap_first + 1, self.num_cities - 1):
+                    before_start = self.best_route[swap_first - 1]
+                    start = self.best_route[swap_first]
+                    end = self.best_route[swap_last]
+                    after_end = self.best_route[swap_last+1]
+                    before = self.distance_matrix[before_start][start] + self.distance_matrix[end][after_end]
+                    after = self.distance_matrix[before_start][end] + self.distance_matrix[start][after_end]
+                    if after < before:
+                        new_route = self.swap(self.best_route, swap_first, swap_last)
+                        new_distance = self.calculate_path_dist(self.distance_matrix, new_route)
+                        self.update(new_route, new_distance)
+
+            improvement_factor = 1 - self.best_distance/previous_best
+        return self.best_route, self.best_distance, self.distances
+
+    @staticmethod
+    def calculate_path_dist(distance_matrix, path):
+        """
+        This method calculates the total distance between the first city in the given path to the last city in the path.
+        """
+        path_distance = 0
+        for ind in range(len(path) - 1):
+            path_distance += distance_matrix[path[ind]][path[ind + 1]]
+        return float("{0:.2f}".format(path_distance))
+
+    @staticmethod
+    def swap(path, swap_first, swap_last):
+        path_updated = np.concatenate((path[0:swap_first],
+                                       path[swap_last:-len(path) + swap_first - 1:-1],
+                                       path[swap_last + 1:len(path)]))
+        return path_updated.tolist()

src/py2opt/solver.py

@@ -0,0 +1,83 @@
+import numpy as np
+from math import sin, cos, sqrt, atan2, radians
+
+
+class GeographicalPositionTest:
+    def __init__(self, file_name):
+        self.file_name = file_name
+
+    def build_dist_matrix(self, cities_names, cities_coordinates):
+        """
+        This function creates a matrix containing pair distance among all cities in kilometers. Distance between each
+        city by itself is equal to zero.
+        """
+        num_cities = len(cities_names)
+        distance_matrix = np.zeros([num_cities, num_cities])
+        for city_departure in cities_names:
+            for city_arrival in cities_names:
+                i = cities_names.index(city_departure)
+                j = cities_names.index(city_arrival)
+                co_i = cities_coordinates[city_departure]
+                co_j = cities_coordinates[city_arrival]
+                distance_matrix[i][j] = self.calculate_pair_dist(co_i, co_j)
+        return distance_matrix
+
+    def open_file(self):
+        city_names = []
+        cities_coordinates = {}
+        with open(self.file_name, "r") as file_stream:
+            num_line = 0
+            for line in file_stream:
+                num_line += 1
+                current_line = line.split(",")
+                if self.is_valid(current_line):
+                    city_name = current_line[0]
+                    city_latitude = float(
+                        "{0:.2f}".format(float(current_line[1]) + float(current_line[2]) / 60))
+                    city_longitude = float(
+                        "{0:.2f}".format(float(current_line[3]) + float(current_line[4]) / 60))
+
+                    cities_coordinates[city_name] = [city_latitude, city_longitude]
+                    city_names.append(city_name)
+                else:
+                    print('This line', num_line, 'does not pass our test.')
+
+            num_cities = len(city_names)
+
+        return cities_coordinates, city_names, num_cities
+
+    @staticmethod
+    def calculate_pair_dist(coordinates_1, coordinates_2):
+        """
+        This function calculates distance between two cities in kilometers given geographical coordinates of two cities.
+        """
+        latitude_first, longitude_first = coordinates_1
+        latitude_second, longitude_second = coordinates_2
+
+        r = 6373.0
+        a = (sin(radians(latitude_second - latitude_first) / 2)) ** 2 + \
+            cos(radians(latitude_first)) * cos(radians(latitude_second)) * \
+            (sin(radians(longitude_second - longitude_first) / 2)) ** 2
+        c = 2 * atan2(sqrt(a), sqrt(1 - a))
+        distance_kilometer = float("{0:.2f}".format(r * c))
+
+        return distance_kilometer
+
+    @staticmethod
+    def is_valid(line):
+        """
+        This boolean function check each line in the imported file to have exact 5 components. Moreover, it checks
+        whether latitude and longitude degrees are between -180 and 180, and its corresponding minutes are between
+        0 and 60.
+        """
+        if len(line) == 5:
+            latitude_degree = float(line[1])
+            latitude_minute = float(line[2])
+            longitude_degree = float(line[3])
+            longitude_minute = float(line[4])
+
+            if -180 <= latitude_degree <= 180 and 0 <= latitude_minute <= 60 and \
+                    -180 <= longitude_degree <= 180 and 0 <= longitude_minute <= 60:
+                return True
+        else:
+            return False

src/py2opt/utils.py

@@ -20,6 +20,7 @@
 from math import *
 from unicorn.context import GCodeContext
 from unicorn.svg_parser import SvgParser
+from py2opt.routefinder import RouteFinder
 
 class MyEffect(inkex.Effect):
   def __init__(self):
@@ -79,8 +80,21 @@ def effect(self):
                            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)
+    
+    inkex.utils.debug(len(parser.entities))
+
+
+    if len(parser.entities) > 1:
+      distance_matrix = parser.get_distance_matrix()
+
+      route_finder = RouteFinder(distance_matrix, parser.entities, iterations=5)
+      best_distance, best_route = route_finder.solve()
+
+      for entity in best_route:
+        entity.get_gcode(self.context)
+    else:
+      for entity in parser.entities:
+        entity.get_gcode(self.context)
 
     MyEffect.save_raw(self, self.context.generate())
 

src/unicorn.py

@@ -1,19 +1,33 @@
-from math import cos, sin, radians
+from math import cos, sin, radians, sqrt, pow
 import pprint
 import warnings
+import inkex
 
 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_starting_point(self):
+		return "NIE"
+	
+	def distance(self, Entity):
+		point_1 = self.get_starting_point()
+		point_2 = Entity.get_starting_point()
+		return sqrt(pow(point_2[0] - point_1[0], 2) + pow(point_2[1] - point_1[1], 2))
+
 	def get_gcode(self,context):
 		#raise NotImplementedError()
 		return "NIE"
 
 class Line(Entity):
 	def __str__(self):
 		return "Line from [%.2f, %.2f] to [%.2f, %.2f]" % (self.start[0], self.start[1], self.end[0], self.end[1])
+	
+	def get_starting_point(self):
+		return self.start
+
 	def get_gcode(self,context):
 		"Emit gcode for drawing line"
 		context.codes.append("(" + str(self) + ")")
@@ -24,6 +38,10 @@ def get_gcode(self,context):
 class Circle(Entity):
 	def __str__(self):
 		return "Circle at [%.2f,%.2f], radius %.2f" % (self.center[0], self.center[1], self.radius)
+	
+	def get_starting_point(self):
+		return (self.center[0] - self.radius, self.center[1])
+
 	def get_gcode(self,context):
 		"Emit gcode for drawing arc"
 		start = (self.center[0] - self.radius, self.center[1])
@@ -39,6 +57,9 @@ def get_gcode(self,context):
 class Arc(Entity):
 	def __str__(self):
 		return "Arc at [%.2f, %.2f], radius %.2f, from %.2f to %.2f" % (self.center[0], self.center[1], self.radius, self.start_angle, self.end_angle)
+	
+	def get_starting_point(self):
+		return self.find_point(0)
 
 	def find_point(self,proportion):
 		"Find point at the given proportion along the arc."
@@ -77,6 +98,12 @@ class PolyLine(Entity):
 	def __str__(self):
 		return "Polyline consisting of %d segments." % len(self.segments)
 
+	def get_starting_point(self):
+		if hasattr(self, 'segments'):
+			return self.segments[0][0]
+		else:
+			return None
+
 	def get_gcode(self,context):
 		"Emit gcode for drawing polyline"
 		if hasattr(self, 'segments'):

src/unicorn/entities.py

@@ -312,10 +312,23 @@ def make_entity(self,node,mat):
       if node.tag == inkex.addNS(tag,ns) or node.tag == tag:
         constructor = SvgParser.entity_map[nodetype]
         entity = constructor()
-        entity.load(node,mat)
-        self.entities.append(entity)
+        if not type(entity).__name__ == "SvgIgnoredEntity":
+          entity.load(node,mat)
+          self.entities.append(entity)
         return entity
     return None
+  
+  def get_distance_matrix(self):
+    ent_len = len(self.entities)
+    distances = []
+
+    for i in range(ent_len):
+      ent_i_distances = []
+      for j in range(ent_len):
+        ent_i_distances.append(self.entities[i].distance(self.entities[j]))
+      distances.append(ent_i_distances)
+
+    return distances
 
 def formatPath(a):
     """Format SVG path data from an array"""