new release adding arbitrary number of pie slices and arbitrary offset

Author: DOSull

Diff for: dist/weavingspace-0.0.3.6.tar.gz

@@ -30,37 +30,37 @@
           0,
           10,
           6,
-          10
+          8
         ]
       },
       {
         "position": [
           0,
-          20,
+          18,
           6,
           2
         ]
       },
       {
         "position": [
           0,
-          22,
+          20,
           6,
           2
         ]
       },
       {
         "position": [
           0,
-          24,
+          23,
           6,
           19
         ]
       },
       {
         "position": [
           0,
-          43,
+          42,
           6,
           5
         ]
@@ -70,45 +70,45 @@
           6,
           10,
           6,
-          8
+          7
         ]
       },
       {
         "position": [
           6,
-          18,
+          17,
           6,
           2
         ]
       },
       {
         "position": [
           6,
-          20,
+          19,
           6,
           2
         ]
       },
       {
         "position": [
           6,
-          22,
+          21,
           6,
           2
         ]
       },
       {
         "position": [
           6,
-          24,
+          23,
           6,
-          18
+          19
         ]
       },
       {
         "position": [
           6,
-          45,
+          42,
           6,
           5
         ]
@@ -118,37 +118,77 @@
           12,
           10,
           6,
-          5
+          6
         ]
       },
       {
         "position": [
           12,
-          15,
+          17,
           6,
           2
         ]
       },
       {
         "position": [
           12,
-          17,
+          19,
           6,
           2
         ]
       },
       {
         "position": [
           12,
-          19,
+          23,
           6,
-          18
+          19
         ]
       },
       {
         "position": [
           12,
-          37,
+          42,
+          6,
+          5
+        ]
+      },
+      {
+        "position": [
+          18,
+          10,
+          6,
+          9
+        ]
+      },
+      {
+        "position": [
+          18,
+          19,
+          6,
+          2
+        ]
+      },
+      {
+        "position": [
+          18,
+          21,
+          6,
+          2
+        ]
+      },
+      {
+        "position": [
+          18,
+          23,
+          6,
+          19
+        ]
+      },
+      {
+        "position": [
+          18,
+          42,
           6,
           5
         ]

Diff for: dist/weavingspace-0.0.3.6-py3-none-any.whl renamed to dist/weavingspace-0.0.4-py3-none-any.whl

@@ -7,10 +7,9 @@ find = {}
 
 [project]
 name = "weavingspace"
-version = "0.0.3.6"
+version = "0.0.4"
 authors = [
   { name="David O'Sullivan", email="[email protected]" },
-  { name="Luke Bergmann" },
 ]
 description = "A package for making tiled mapping layers"
 requires-python = ">=3.12"

Diff for: dist/weavingspace-0.0.4.tar.gz

@@ -113,7 +113,7 @@ def _(mo):
     mo.md(
         r"""
         ## Hexagon and square slices
-        We can slice base hexagon or square tilings into pie segments, with a fractional offset from the base polygon corner.
+        Pie slices of hexagons or squares, with an offset specifying how far along from start to midpoint of the first segment slices should start.
         """
     )
     return
@@ -125,7 +125,7 @@ def _(mo):
         options=["hex-slice", "square-slice"],
         value="hex-slice"
     )
-    mo.md(f"#### Slice or dissection? {hex_or_square_slice}")
+    mo.md(f"#### Hex or square? {hex_or_square_slice}")
     return (hex_or_square_slice,)
 
 
@@ -157,19 +157,19 @@ def _(
     t_inset,
     tile_rotate,
 ):
-    hex = TileUnit(tiling_type=hex_or_square_slice.value, 
+    slices = TileUnit(tiling_type=hex_or_square_slice.value, 
                    n=n_slices.value, offset=offset_slices.value) \
       .transform_scale(math.sqrt(aspect.value), 1/math.sqrt(aspect.value)) \
       .transform_rotate(tile_rotate.value) \
       .inset_tiles(t_inset.value) \
       .inset_prototile(p_inset.value)
-    plot_tiles(hex)
-    return (hex,)
+    plot_tiles(slices)
+    return (slices,)
 
 
 @app.cell
-def _(hex, hex_or_square_slice, mo, n_slices, offset_slices):
-    _download_button = mo.download(data=hex.tiles.to_json().encode('utf-8'), 
+def _(hex_or_square_slice, mo, n_slices, offset_slices, slices):
+    _download_button = mo.download(data=slices.tiles.to_json().encode('utf-8'), 
                 filename=f'{hex_or_square_slice.value}-{n_slices.value}-{offset_slices.value:.3f}_tile_unit.json', 
                 mimetype='text/plain', label='Download')
     mo.md(f'Click to download **square/hex slice** tile unit {_download_button}')
@@ -178,7 +178,71 @@ def _(hex, hex_or_square_slice, mo, n_slices, offset_slices):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""## Laves tilings and their Archimedean duals""")
+    mo.md(
+        """
+        ## Hex dissections
+        4, 7 and 9 dissections of the hexagon in two different varieties.
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(list_to_dict, mo):
+    n_pieces = mo.ui.dropdown(
+        options = list_to_dict([4, 7, 9]),
+        value = "7"
+    )
+    mo.md(f"#### Number of pieces  {n_pieces}")
+    return (n_pieces,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    dissection_offset = mo.ui.switch(value = True)
+    mo.md(f"#### Start from corners?  {dissection_offset}")
+    return (dissection_offset,)
+
+
+@app.cell(hide_code=True)
+def _(
+    TileUnit,
+    aspect,
+    dissection_offset,
+    math,
+    n_pieces,
+    p_inset,
+    plot_tiles,
+    t_inset,
+    tile_rotate,
+):
+    pieces = TileUnit(tiling_type="hex-dissection", 
+                   n=n_pieces.value, offset=0 if dissection_offset.value else 1) \
+      .transform_scale(math.sqrt(aspect.value), 1/math.sqrt(aspect.value)) \
+      .transform_rotate(tile_rotate.value) \
+      .inset_tiles(t_inset.value) \
+      .inset_prototile(p_inset.value)
+    plot_tiles(pieces)
+    return (pieces,)
+
+
+@app.cell
+def _(dissection_offset, mo, n_pieces, pieces):
+    _download_button = mo.download(data=pieces.tiles.to_json().encode('utf-8'), 
+                filename=f'hex-dissection-{n_pieces.value}-{dissection_offset.value}_tile_unit.json', 
+                mimetype='text/plain', label='Download')
+    mo.md(f'Click to download **Hex dissection** tile unit {_download_button}')
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## Laves tilings and their Archimedean duals
+        The Laves tilings are monohedral. They are dual to the Archimedean tilings by regular polygons. We support 7 of the 11 possible tilings.
+        """
+    )
     return
 
 

Diff for: layouts/tiling-explorer.grid.json

@@ -1,8 +1,7 @@
 Metadata-Version: 2.2
 Name: weavingspace
-Version: 0.0.3.6
+Version: 0.0.4
 Summary: A package for making tiled mapping layers
-Author: Luke Bergmann
 Author-email: David O'Sullivan <[email protected]>
 Project-URL: Homepage, https://github.com/DOSull/weaving-space
 Project-URL: Repository, https://github.com/DOSull/weaving-space

Diff for: pyproject.toml

@@ -127,14 +127,17 @@ def setup_cairo(unit:"TileUnit") -> None:
 
 
 def setup_hex_slice(unit:"TileUnit") -> None:
-  """Tilings from radial slices of a hexagon into 2, 3, 4, 6 or 12 slices.
+  """Arbitrary number of radial slices of a hexagon, with an optional
+  offset starting point.
 
   The supplied unit should have offset and n set.
 
-  self.offset == 1 starts at midpoints, 0 at hexagon corners
-  self.n is the number of slices and should be 2, 3, 4, 6 or 12.
-
-  Again, construction avoids intersection operations where possible.
+  Places unit.n points equally spaced around the perimeter of the hexagon.
+  Slices are formed by connecting some sequence of these points (and any
+  intervening hexagon corners) and the hexagon centre to form a pie slice.
+  unit.offset = 0 starts from corner 0. unit.offset starts half way between
+  corner 0 and corner 1. Other values of unit.offset scale linear between
+  these.
 
   Args:
     unit (TileUnit):  the TileUnit to setup.
@@ -150,14 +153,17 @@ def setup_hex_slice(unit:"TileUnit") -> None:
 
 
 def setup_square_slice(unit:"TileUnit") -> None:
-  """Tilings from radial slices of a square into 2, 4, or 8 slices.
+  """Arbitrary number of radial slices of a square, with an optional
+  offset starting point.
 
   The supplied unit should have offset and n set.
 
-  self.offset == 1 starts at midpoints, 0 at corners
-  self.n is the number of slices and should be 2, 4, or 8.
-
-  Again, construction avoids intersection operations where possible.
+  Places unit.n points equally spaced around the perimeter of the square.
+  Slices are formed by connecting some sequence of these points (and any
+  intervening squares corners) and the square centre to form a pie slice.
+  unit.offset = 0 starts from corner 0. unit.offset starts half way between
+  corner 0 and corner 1. Other values of unit.offset scale linear between
+  these.
 
   Args:
     unit (TileUnit):  the TileUnit to setup.