weavingspace 0.0.1__tar.gz

weavingspace-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022-25 David O'Sullivan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weavingspace-0.0.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.2
+Name: weavingspace
+Version: 0.0.1
+Summary: A package for making tiled mapping layers
+Author-email: David O'Sullivan <osullivan512@gmail.com>
+License: Copyright (c) 2022-25 David O'Sullivan
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/DOSull/weaving-space
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: importlib-metadata; python_version >= "3.12"
+Requires-Dist: geopandas
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: networkx
+Requires-Dist: pillow
+Requires-Dist: matplotlib
+Requires-Dist: dataclasses
+Requires-Dist: typing
+
+# Geographical weaving
+This is work in progress towards developing tiled geospatial data layers for symbolisation of complex multi-attribute choropleths.  
+
+The original proof-of-concept code is in R and Rmd files in the `r-stuff` folder. Needed datasets to run the code are in the `data` folder.
+
+## **Update** (*April 2022*) 
+There is now a working version in python using `geopandas` and `shapely`. It will be more extensible in the longer run and will be the basis of any further work at this stage. The python implementation also appears less prone to topological glitches when tiles are dissolved to form tilings and does not require that we use any additional libraries to get reasonable(ish) performance when tiling large maps. The python source is in the `weavingspace` folder. 
+
+There are several jupyter notebooks in this repo that show examples of how to use the codebase, and the API is documented [here](https://dosull.github.io/weaving-space/doc/weavingspace.html).
+
+## Talks
+An overview of the concepts assembled from the proof-of-concept _R_ code is on [this webpage](https://dosull.github.io/weaving-space/NZCS-Nov-2021/make-weave-map.html). A similar follow-up talk is [available here](https://dosull.github.io/weaving-space/Palmerston-North-Nov-2022/slides/index.html)
+
+Slides from a more recent talk explaining the work, extended to tiled maps (of which woven maps are a special case) is available [here](https://dosull.github.io/weaving-space/Palmerston-North-Nov-2022/slides/).

weavingspace-0.0.1/README.md

@@ -0,0 +1,14 @@
+# Geographical weaving
+This is work in progress towards developing tiled geospatial data layers for symbolisation of complex multi-attribute choropleths.  
+
+The original proof-of-concept code is in R and Rmd files in the `r-stuff` folder. Needed datasets to run the code are in the `data` folder.
+
+## **Update** (*April 2022*) 
+There is now a working version in python using `geopandas` and `shapely`. It will be more extensible in the longer run and will be the basis of any further work at this stage. The python implementation also appears less prone to topological glitches when tiles are dissolved to form tilings and does not require that we use any additional libraries to get reasonable(ish) performance when tiling large maps. The python source is in the `weavingspace` folder. 
+
+There are several jupyter notebooks in this repo that show examples of how to use the codebase, and the API is documented [here](https://dosull.github.io/weaving-space/doc/weavingspace.html).
+
+## Talks
+An overview of the concepts assembled from the proof-of-concept _R_ code is on [this webpage](https://dosull.github.io/weaving-space/NZCS-Nov-2021/make-weave-map.html). A similar follow-up talk is [available here](https://dosull.github.io/weaving-space/Palmerston-North-Nov-2022/slides/index.html)
+
+Slides from a more recent talk explaining the work, extended to tiled maps (of which woven maps are a special case) is available [here](https://dosull.github.io/weaving-space/Palmerston-North-Nov-2022/slides/).

weavingspace-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "weavingspace"
+version = "0.0.1"
+authors = [
+  { name="David O'Sullivan", email="osullivan512@gmail.com" },
+]
+description = "A package for making tiled mapping layers"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+readme = "README.md"
+license = {file = "LICENSE"}
+dependencies = [
+    "requests",
+    'importlib-metadata; python_version>="3.12"',
+    "geopandas",
+    "pandas",
+    "numpy",
+    "scipy",
+    "shapely",
+    "networkx",
+    "pillow",
+    "matplotlib",
+    "dataclasses",
+    "typing",
+]
+
+[project.urls]
+Homepage = "https://github.com/DOSull/weaving-space"

weavingspace-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

weavingspace-0.0.1/src/__init__.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+"""
+See [this notebook](https://github.com/DOSull/weaving-space/blob/main/using-the-library.ipynb) for some preliminary usage notes.
+"""
+
+from .tiling_utils import *
+from ._loom import *
+from ._weave_grid import *
+from .tileable import *
+from .tiling_geometries import *
+from .tile_unit import *
+from .weave_matrices import *
+from .weave_unit import *
+from .tile_map import *
+from .symmetry import *
+from .topology_elements import *
+from .topology import *

weavingspace-0.0.1/src/_loom.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+_decode_orders = (
+  {1: (0,  ), 2: (1,  ), 3: (   ), 4: (0, 1), 5: (1, 0)},
+  {1: (1,  ), 2: (0,  ), 3: (   ), 4: (1, 0), 5: (0, 1)},
+  {1: (2,  ), 2: (1,  ), 3: (   ), 4: (2, 1), 5: (1, 2)},
+  {1: (0,  ), 2: (2,  ), 3: (   ), 4: (0, 2), 5: (2, 0)}
+)
+"""Initially in a biaxial weave intersection sites are encoded numerically:
+
+  1 = warp is absent
+  2 = weft is absent
+  3 = both threads are absent
+  4 = weft is on top
+  5 = warp is on top
+
+this tuple of dictionaries translates these to tuples listing the 'layer' order
+depending on the input axis, where item 0 is the biaxial case with layers 0 and
+1 only, item 1 is layers 0 and 1, item 2 is layers 1 and 2, and item 3 is
+layers 2 and 0.
+"""
+
+_combined_orderings = {
+  (    ): {(    ): {(    ): None,        # All absent
+           (2,  ):  (2,  )},             # Only 2 present
+           (1,  ): {(    ): (1,  )},     # Only 1 present
+           (2,  ): {(2,  ): (2,  )}},    # Only 2 present
+  (0,  ): {(    ): {(0,  ): (0,  ),      # Only 0 present
+           (    ):  (0,  )},             # Only 0 present
+           (2,  ): {(2, 0): (2, 0),      # 0 2 20 --> 2 > 0
+           (0, 2):  (0, 2)}},            # 0 2 02 --> 0 > 2
+  (1,  ): {(1,  ): {(    ): (1,  )},     # Only 1 present
+           (1, 2): {(2,  ): (1, 2)},     # 1 12 2 --> 1 > 2
+           (2, 1): {(2,  ): (2, 1)}},    # 1 21 2 --> 2 > 1
+  (0, 1): {(1,  ): {(0,  ): (0, 1)},     # 01 1 0 --> 0 > 1
+           (1, 2): {(0, 2): (0, 1, 2)},  # 01 12 02 --> 0 > 1 > 2
+           (2, 1): {(2, 0): (2, 0, 1),   # 01 21 20 --> 2 > 0 > 1
+           (0, 2): (0, 2, 1)}},          # 01 21 02 --> 0 > 2 > 1
+  (1, 0): {(1,  ): {(0,  ): (1, 0)},     # 10 1 0 --> 1 > 0
+           (1, 2): {(2, 0): (1, 2, 0),   # 10 12 20 --> 1 > 2 > 0
+           (0, 2):  (1, 0, 2)},          # 10 12 02 --> 1 > 0 > 2
+           (2, 1): {(2, 0): (2, 1, 0)}}  # 10 21 20 --> 2 > 1 > 0
+}
+"""Nested dictionary to combine layer orders from 3 biaxial weaves
+into a single consistent order of layers. Inconsistent combinations
+will not return a value. Layers 0 and 1 are present in the first 'tier',
+layers 1 and 2 in the second and 2 and 0 in the third.
+"""
+
+
+@dataclass
+class Loom:
+  """A collection of weave matrices and associated attributes.
+
+  Central to the loom object are the indices and orderings lists. These
+  list the grid coordinate pairs and corresponding layer orderings at the
+  site indexed by the coordinates. E.g., for a simple plain weave, we have:
+
+    indices: [(0, 0), (0, 1), (1, 0), (1, 1)]
+    orderings: [(0, 1), (1, 0), (1, 0), (0, 1)]
+  """
+  indices: list[tuple]
+  """grid coordinate pairs."""
+  orderings: list
+  """list of layer orders at site locations index by corresponding times in
+  `indices`."""
+  dimensions: tuple
+  """maximum coordinate values in each direction."""
+  orientations: tuple
+  """angles (in degrees) which strands on each axis make with the x-axis.
+  (0, -90) for 2 axes, (0, 120, 240) for 3."""
+  n_axes: int
+  """number of axes, 2 or 3."""
+
+  def __init__(self, *matrices:np.ndarray):
+    """Constructor for a Loom. Takes either one or three weave matrices
+    as input and initialises the loom based on these.
+    """
+    if len(matrices) == 1:
+      m = matrices[0]
+      self.dimensions = m.shape
+      self.n_axes = len(self.dimensions)
+      # self.parity = None
+      self.orientations = (0, -90)
+      self.indices = [(i, j) for i in range(m.shape[0])
+                   for j in range(m.shape[1])]
+      self.orderings = [_decode_orders[0][m[ij]] for ij in self.indices]
+    else:
+      nA, nB, nC = [max(m.shape) for m in matrices]
+      self.dimensions = (nA, nB, nC)
+      self.n_axes = len(self.dimensions)
+      self.orientations = (0, 120, 240)
+      all_indices = [(i, j, k) for i in range(nA)
+                   for j in range(nB)
+                   for k in range(nC)]
+      # parity is used to select coordinate triples in the grid see:
+      # Nagy BN 2003. Shortest Paths in Triangular Grids with
+      # Neighbourhood Sequences. Journal of Computing and Information
+      # Technology 11 (2):111
+      parity = (nA + nB + nC - 3) // 2
+      self.indices = [x for x in all_indices if sum(x) in (parity, parity + 1)]
+      m1, m2, m3 = matrices
+      # extend the input 2D grids if needed
+      mAB = np.tile(m1, (np.lcm(nA, m1.shape[0]) // m1.shape[0],
+                         np.lcm(nA, m1.shape[1]) // m1.shape[1]))
+      mBC = np.tile(m2, (np.lcm(nB, m2.shape[0]) // m2.shape[0],
+                         np.lcm(nB, m2.shape[1]) // m2.shape[1]))
+      mCA = np.tile(m3, (np.lcm(nC, m3.shape[0]) // m3.shape[0],
+                         np.lcm(nC, m3.shape[1]) // m3.shape[1]))
+      # get the layer orders in each using 2 of the 3 coordinates
+      ordAB = [_decode_orders[1][mAB[ij]]
+               for ij in [(x[1], x[0]) for x in self.indices]]
+      ordBC = [_decode_orders[2][mBC[ij]]
+               for ij in [(x[2], x[1]) for x in self.indices]]
+      ordCA = [_decode_orders[3][mCA[ij]]
+               for ij in [(x[0], x[2]) for x in self.indices]]
+      # # combine orders from the three matrices stacked
+      self.orderings = [self._combine_orders(abc)
+                        for abc in zip(ordAB, ordBC, ordCA)]
+
+
+  # convenience wrapper for the combined_orderings dictionary
+  # missing values return "NA"
+  def _combine_orders(self, orders):
+    # print(f"orders: {orders}")
+    try:
+      result = _combined_orderings[orders[0]][orders[1]][orders[2]]
+    except:
+      print(f"Unable to determine unique ordering on {orders}")
+      return "NA"
+    else:
+      return result

weavingspace-0.0.1/src/_weave_grid.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+from typing import Union
+from dataclasses import dataclass
+
+import numpy as np
+
+import shapely.affinity as affine
+import shapely.geometry as geom
+import shapely.ops
+import shapely.wkt as wkt
+
+import weavingspace.tiling_utils as tiling_utils
+
+@dataclass
+class WeaveGrid:
+  """Class to encapsulate generation of sites where strands intersect.
+
+  Can generate both triangular and square grid 'cells' as visual
+  representation of overlaps of two or three strands at a site.
+
+  NOTE: there is no 'gridification' or 'cleaning' in the geometry of this
+  code - we leave that to steps further down the pipeline, preferring to
+  perform this low level geometry with maximum precision. The only limited
+  break with this is in get_visible_cell_strands, where strands in higher
+  layers are buffered by a small amount to avoid closely aligned polygon
+  edges producing slivers etc.
+  
+  Atrributes:
+    basis (np.ndarray): matrix to calculate x,y coordinates of a
+      site from its (integer) grid coordinates,
+    orientations (tuple[float]: orientations of the two or three
+      axes either (0, -90) or (0, 120, 240).
+    grid_cell (geom.Polygon): the base triangle or square of the grid.
+    n_axes (int): the number of axes in the weave, 2 or 3.
+      Defaults to 2.
+    spacing (float): spacing of the strands. Defaults to 10_000.
+  """
+  basis: np.ndarray
+  orientations: tuple[float]
+  grid_cell: geom.Polygon = None
+  n_axes: int = None
+  spacing: float = 10000
+
+  def __init__(self, n_axes, orientations, spacing = 10000):
+    """Initialises _WeaveGrid.
+    """
+    self.n_axes = n_axes
+    self.orientations = orientations
+    self.spacing = spacing
+    self.basis = self.setup_basis()
+    self.grid_cell = self._make_grid_cell()
+
+  def setup_basis(self) -> np.ndarray:
+    """Sets up the basis of the grid coordinate generation matrix.
+
+    Returns:
+      np.nd.array: self.n_axes x 2 matrix to generate float coordinates
+        of cells in Cartesian space from integer grid coordinates of
+        cells.
+    """
+    # angles are perpendicular to the direction of their respective strands
+    # so e.g. 2nd strand in 3 axis case is at 120, and perpendicular is 210
+    if self.n_axes == 2:
+      angles = (np.pi / 2, 0)
+      dx = [self.spacing * np.cos(a) for a in angles]  # [0, 1]
+      dy = [self.spacing * np.sin(a) for a in angles]  # [1, 0]
+    elif self.n_axes == 3:
+      angles = [np.pi / 6 * x for x in range(3, 12, 4)]  # [90, 210, 330]
+      dx = [self.spacing * 2 / 3 * np.cos(a) for a in angles]
+      dy = [self.spacing * 2 / 3 * np.sin(a) for a in angles]
+    return np.array(dx + dy).reshape((2, self.n_axes))
+
+
+  def get_coordinates(self, coords: tuple) -> np.ndarray:
+    """Uses self.basis to determine Cartesian coordinates of cell centroid
+    from grid coordinates.
+
+    Args:
+      coords (tuple[int]): integer coordinate pair of grid location.
+
+    Returns:
+      np.ndarray: float coordinate pair of grid cell centroid.
+    """
+    return self.basis @ coords
+
+
+  def get_grid_cell_at(self, coords: tuple[int] = None) -> geom.Polygon:
+    """Returns grid cell polygon centred on coords.
+
+    Args:
+      coords (tuple[int], optional): _description_. Defaults to None.
+
+    Returns:
+      geom.Polygon: square or triangle centred at the specified
+        coordinates.
+    """
+    if coords is None:
+      coords = tuple([0] * self.n_axes)
+    if self.grid_cell is None:
+      polygon = self._make_grid_cell()
+    else:
+      polygon = self.grid_cell
+      xy = self.get_coordinates(coords)
+      polygon = affine.translate(polygon, xy[0], xy[1])
+    if self.n_axes == 2 or sum(coords) %2 == 0:
+      return polygon
+    else:
+      return affine.rotate(polygon, 180, origin = polygon.centroid)
+
+
+  def _make_grid_cell(self) -> geom.Polygon:
+    r"""Returns base cell polygon for this _WeaveGrid
+
+    Grid cell is centred at (0, 0) with  number of sides dependent
+    on self.n_axes. One side of polygon will be horizontal below the
+    x-axis symmetric about the y-axis. Radii to corners are either
+
+    n_axes=2:   n_axes=3:
+      \  /          |
+       \/           |
+       /\          / \
+      /  \        /   \
+
+    face to face distance of cell from base vertically to the opposite face
+    or corner is (square) L = 2 Rcos(45), or (triangle) L = R + Rcos(60) where R is the radius of the circumcircle.
+
+    Polygon is generated by finding points equally spaced on the
+    circumcircle. Note that the code could easily be altered to return a
+    hexagon, if the need arises (this would require a change to the basis
+    calculation also).
+
+    Returns:
+      Polygon: square or triangular cell of appropriate size i.e. spacing
+        centred at (0, 0).
+    """
+    n_sides = 4 if self.n_axes == 2 else 3
+    if n_sides == 4:
+      R = self.spacing / (2 * np.cos(np.pi / n_sides))
+    else:
+      R = self.spacing / (1 + np.cos(np.pi / n_sides))
+    angles = self._get_angles(n_sides)
+    corners = [(R * np.cos(a), R * np.sin(a)) for a in angles]
+    return geom.Polygon(corners)
+
+
+  def _get_angles(self, n: int = 4) -> list[float]:
+    """Returns angles to corners of n sides polygon, assuming one side is horizontal parallel to x-axis.
+
+    To determine angles start at 6 o'clock (3pi/2) and add (pi/n), then
+    subtract a series of n - 1 2pi/n steps. Note we subtract due to the CW
+    polygon winding order convention
+
+    Args:
+      n (int, optional): Number of sides. Defaults to 4.
+
+    Returns:
+      list[float]: angles in radians.
+    """
+    return [(3 * np.pi/2) + (np.pi/n) - (i/n * 2 * np.pi) for i in range(n)]
+
+
+  def _get_grid_cell_slices(self, L:float, W:float = 1,
+                n_slices:int = 1) -> list[geom.Polygon]:
+    r"""Gets list of rectangular polygons represneting 'slices' across cell.
+
+    Returns 'slices' across grid cell (i.e. horizontally) centred vertically
+    relative to the cell, ie
+
+             /\
+            /  \
+    +------------------+
+    |     /      \     |
+    +------------------+
+    |   /          \   |
+    +------------------+
+      /              \
+     /________________\
+
+    Horizontal extent is L, total width of the strips is W * self.spacing,
+    they are 'sliced' horizontally in n_slices slices of equal width.
+
+    Args:
+      L (float, optional): length of slices. Defaults to 0.
+      W (float, optional): width of slices relative to grid spacing.
+        Defaults to 1.
+      n_slices (int, optional): number of slices to divide strands into
+        along their length. Defaults to 1.
+
+    Returns:
+      list[geom.Polygon]: _description_
+    """
+    L = self.spacing if L == 0 else L
+    # note that strand width is based on self.spacing, not L because L
+    # may be larger if generating slices for aspect < 1 when strands
+    # will extend outside grid cell.
+    strand_w = self.spacing * W
+    slice_w = strand_w / n_slices
+    odd_numbers = [x for x in range(1, 2 * n_slices, 2)]
+    slice_offsets = [(slice_w * o / 2) - (strand_w / 2) for o in odd_numbers]
+    base_slice = geom.Polygon([(-L/2, -slice_w/2), (-L/2,  slice_w/2),
+                               ( L/2,  slice_w/2), ( L/2, -slice_w/2)])
+    return [affine.translate(base_slice, 0, offset) 
+        for offset in slice_offsets]
+    
+
+  def _get_cell_strands(
+      self, width:float = 1.0, coords:tuple[int] = None,
+      orientation:int = 0, n_slices:int = 1
+    ) -> list[Union[geom.Polygon,geom.MultiPolygon]]:
+    """Gets n_slices cells strands with specified total width across the
+    grid cell at coords at orientation.
+
+    Args:
+      width (float, optional): total width of strands relative to
+        self.spacing. Defaults to 1.0.
+      coords (tuple[int], optional): integer grid coordinates of
+        cell. Defaults to None.
+      orientation (int, optional): orientation of the strands.
+        Defaults to 0.
+      n_slices (int, optional): number of length-wise slices to cut
+        strands into. Defaults to 1.
+
+    Returns:
+      list[Union[geom.Polygon,geom.MultiPolygon]]: polygons representing the 
+        strands.
+    """
+    cell = self.get_grid_cell_at(coords)
+    # when aspect is <1 strands extend outside cell by some scale factor
+    sf = 2 - width if self.n_axes == 2 else (5 - 3 * width) / 2
+    expanded_cell = affine.scale(cell, sf, sf, origin = cell.centroid)
+    big_l = (sf * self.spacing       ## rectangular case is simple
+             if self.n_axes == 2     ## triangular less so!
+             else sf * self.spacing * 2 / np.sqrt(3) * (3 - width) / 2)
+    strands = geom.MultiPolygon(
+      self._get_grid_cell_slices(L = big_l, W = width, n_slices = n_slices))
+    # we need centre of cell bounding box to shift strands to 
+    # vertical center of triangular cells. In rectangular case
+    # this will be (0, 0).
+    cell_offset = cell.envelope.centroid
+    strands = affine.translate(strands, cell_offset.x, cell_offset.y)
+    strands = geom.MultiPolygon(
+        [expanded_cell.intersection(s) for s in strands.geoms])
+    strands = affine.rotate(strands, orientation, origin = cell.centroid)
+    return [s for s in strands.geoms]
+
+
+  def get_visible_cell_strands(
+      self, width:float= 1.0, coords:tuple[int] = None,
+      strand_order:tuple[int] = (0, 1, 2), n_slices:tuple[int] = (1, 1, 1)
+    ) -> list[Union[geom.Polygon,geom.MultiPolygon]]:
+    """Returns visible strands in grid cell based on layer order.
+
+    Returns visible parts of the strands in a grid cell, given strand width, strand layer order and the number of slices in each direction.
+
+    Args:
+      width (float): total width of strands relative to self.spacing.
+        Defaults to 1.0.
+      coords (tuple[int], optional): grid cell coordinates. Defaults
+        to None.
+      strand_order (tuple[int], optional): order of the layers from top,
+        at this cell site. Defaults to (0, 1, 2).
+      n_slices (tuple[int], optional): number of slices in each layer
+        at this cell site. Defaults to (1, 1, 1).
+
+    Returns:
+      list[Union[geom.Polygon,geom.MultiPolygon]]: those polygons that
+        will be visible at this site given requested strand order from
+        the top.
+    """
+    all_polys = []
+    for order in strand_order[:self.n_axes]:
+        next_polys = self._get_cell_strands(width, coords, 
+                                            self.orientations[order], 
+                                            n_slices[order])
+        if all_polys == []:
+            all_polys.extend(next_polys)
+            mask = shapely.unary_union(next_polys)
+        else:
+            # buffering the mask cleans up many issues with closely
+            # aligned polygon edges in overlayed layers
+            all_polys.extend([p.difference(
+              mask.buffer(tiling_utils.RESOLUTION, join_style = 2, cap_style = 3)) 
+              for p in next_polys])
+            mask = mask.union(shapely.unary_union(next_polys))
+    return all_polys
+
+
+  def get_tile_from_cells(self, approx_tile:geom.Polygon) -> geom.Polygon:
+    """Returns a rectangle or hexagon derived from the bounds of the
+    supplied approximation to a tile.
+
+    This is required because we know the required tile is an exact 4 or
+    6 cornered polygon, but the MultiPolygon formed by unary_union is likely
+    to have many more corners than this (for some reason...).
+
+    Args:
+      approx_tile (geom.Polygon): MultiPolygon formed from the cells of
+        the tile.
+
+    Returns:
+      geom.Polygon (geom.Polygon): rectangle or hexagon geom.Polygon.
+    """
+    xmin, ymin, xmax, ymax = approx_tile.bounds
+    if self.n_axes == 2:
+      w = np.round((xmax - xmin) / self.spacing) * self.spacing
+    else:
+      h_spacing = self.spacing * 2 / np.sqrt(3)
+      w = np.round((xmax - xmin) / h_spacing) * h_spacing
+    h = np.round((ymax - ymin) / self.spacing) * self.spacing
+    if self.n_axes == 2:
+      return geom.Polygon([(-w/2, -h/2), (-w/2, h/2),
+                           (w/2, h/2), (w/2, -h/2)])
+    else:
+      return geom.Polygon([(w/4, -h/2), (-w/4, -h/2), (-w/2, 0),
+                           (-w/4, h/2), ( w/4, h/2), (w/2, 0)])
+
+
+  # THIS IS HERE FOR SAFE KEEPING... at various times the shapely.set_precision
+  # function causes havoc in this class, and the below has proven more stable
+  # Note that the more aggressive precision setting here might be relevant also
+  # def _gridify(self, shape: geom.Polygon, precision = 4) -> geom.Polygon:
+  #   """Returns polygon with coordinates at specified precision.
+    
+  #   IMPORTANT (and not understood...!!!). This local method seems to work 
+  #   better on the kinds of gridification required for the weave grid polygons 
+  #   to work... I have no idea why. It may relate to the reordering of 
+  #   coordinates that shapely.set_precision engages in... or... it might not. 
+  #   It clearly has something to do with floating point issues. I JUST DON'T 
+  #   KNOW...
+    
+  #   TODO: Figure this the hell out at some point!
+
+  #   Args:
+  #     shape (geom.Polygon): polygon to gridify.
+  #     precision (int): digits of precision. Defaults to 4.
+
+  #   Returns:
+  #     geom.Polygon: gridified polygon.
+  #   """
+  #   return wkt.loads(wkt.dumps(shape, rounding_precision = precision))
+