add tiles

1 files changed, 136 insertions, 0 deletions

diff --git a/lib/tiles.py b/lib/tiles.py
new file mode 100644
index 00000000..34097f67
--- /dev/null
+++ b/lib/tiles.py
@@ -0,0 +1,136 @@
+import inkex
+from math import ceil, floor
+from networkx import Graph
+import os
+from shapely.geometry import LineString
+from shapely.prepared import prep
+
+from .svg import apply_transforms
+from .utils import get_bundled_dir, guess_inkscape_config_path, Point
+from random import random
+
+
+class Tile:
+    def __init__(self, path):
+        self._load_tile(path)
+
+    def _load_tile(self, tile_path):
+        tile_svg = inkex.load_svg(tile_path)
+        self.name = self._get_name(tile_path)
+        self._load_paths(tile_svg)
+        self._load_dimensions(tile_svg)
+        self._load_buffer_size(tile_svg)
+        self._load_parallelogram(tile_svg)
+
+    def __repr__(self):
+        return f"Tile({self.name}, {self.shift0}, {self.shift1})"
+
+    __str__ = __repr__
+
+    def _get_name(self, tile_path):
+        return os.path.splitext(os.path.basename(tile_path))[0]
+
+    def _load_paths(self, tile_svg):
+        path_elements = tile_svg.findall('.//svg:path', namespaces=inkex.NSS)
+        self.tile = self._path_elements_to_line_strings(path_elements)
+        # self.center, ignore, ignore = self._get_center_and_dimensions(self.tile)
+
+    def _load_dimensions(self, tile_svg):
+        svg_element = tile_svg.getroot()
+        self.width = svg_element.viewport_width
+        self.height = svg_element.viewport_height
+
+    def _load_buffer_size(self, tile_svg):
+        circle_elements = tile_svg.findall('.//svg:circle', namespaces=inkex.NSS)
+        if circle_elements:
+            self.buffer_size = circle_elements[0].radius
+        else:
+            self.buffer_size = 0
+
+    def _load_parallelogram(self, tile_svg):
+        parallelogram_elements = tile_svg.findall(".//svg:*[@class='para']", namespaces=inkex.NSS)
+        if parallelogram_elements:
+            path_element = parallelogram_elements[0]
+            path = apply_transforms(path_element.get_path(), path_element)
+            subpaths = path.to_superpath()
+            subpath = subpaths[0]
+            points = [Point.from_tuple(p[1]) for p in subpath]
+            self.shift0 = points[1] - points[0]
+            self.shift1 = points[2] - points[1]
+        else:
+            self.shift0 = Point(self.width, 0)
+            self.shift1 = Point(0, self.height)
+
+    def _path_elements_to_line_strings(self, path_elements):
+        lines = []
+        for path_element in path_elements:
+            path = apply_transforms(path_element.get_path(), path_element)
+            for subpath in path.to_superpath():
+                # We only care about the endpoints of each subpath.  They're
+                # supposed to be simple line segments.
+                lines.append([Point.from_tuple(subpath[0][1]), Point.from_tuple(subpath[-1][1])])
+
+        return lines
+
+    def _get_center_and_dimensions(self, shape):
+        min_x, min_y, max_x, max_y = shape.bounds
+        center = Point((max_x + min_x) / 2, (max_y + min_y) / 2)
+        width = max_x - min_x
+        height = max_y - min_y
+
+        return center, width, height
+
+    def translate_tile(self, shift):
+        translated_tile = []
+
+        for start, end in self.tile:
+            start += shift
+            end += shift
+            translated_tile.append((start.as_int().as_tuple(), end.as_int().as_tuple()))
+
+        return translated_tile
+
+    def to_graph(self, shape, only_inside=True, pad=True):
+        """Apply this tile to a shape, repeating as necessary.
+
+        Return value:
+            networkx.Graph with edges corresponding to lines in the pattern.
+              Each edge has an attribute 'line_string' with the LineString
+              representation of this edge.
+        """
+        shape_center, shape_width, shape_height = self._get_center_and_dimensions(shape)
+        shape_diagonal = (shape_width ** 2 + shape_height ** 2) ** 0.5
+        graph = Graph()
+
+        if pad:
+            shape = shape.buffer(-self.buffer_size)
+
+        prepared_shape = prep(shape)
+
+        tiles0 = ceil(shape_diagonal / self.shift0.length()) + 2
+        tiles1 = ceil(shape_diagonal / self.shift1.length()) + 2
+        for repeat0 in range(floor(-tiles0 / 2), ceil(tiles0 / 2)):
+            for repeat1 in range(floor(-tiles1 / 2), ceil(tiles1 / 2)):
+                shift0 = repeat0 * self.shift0 + shape_center
+                shift1 = repeat1 * self.shift1 + shape_center
+                this_tile = self.translate_tile(shift0 + shift1)
+                for line in this_tile:
+                    line_string = LineString(line)
+                    if not only_inside or prepared_shape.contains(line_string):
+                        graph.add_edge(line[0], line[1], line_string=line_string, weight=random() + 0.1)
+
+        return graph
+
+
+def all_tile_paths():
+    return [os.path.join(guess_inkscape_config_path(), 'tiles'),
+            get_bundled_dir('tiles')]
+
+
+def all_tiles():
+    for tile_dir in all_tile_paths():
+        try:
+            for tile_file in sorted(os.listdir(tile_dir)):
+                yield Tile(os.path.join(tile_dir, tile_file))
+        except FileNotFoundError:
+            pass