How to make {7,3} with zigzag rays?

[lancejpollard]

Trying to make this pretty much:

Essentially the 7 zigzag rays (image from Maurice Margenstern's work).

But, this isn't even perfect, for example the 7 tiles surrounding the center tile are slightly off center alignment (look at the vertical ray line at coming out of center tile's top vertex, slightly off). So my understanding is:

1. Somewhat shrink the first ring of tiles a tiny bit to create a gap between each one, and adjust the tile position a tiny bit.
2. Shrink the next ring of tiles globally, so they fit with a gap every 3rd tile, and yet let them fill the space fully, stretching maybe even a little?
3. Shrink the next ring likewise, so there is a gap every 8th tile, etc..

Working with ClaudeCode, I got the basic {7,3} tiling working:

import math
import drawsvg as draw
from drawsvg import Drawing
from hyperbolic import euclid
from hyperbolic.poincare import *
import hyperbolic.tiles as htiles

# Create {7,3} tiling using direct approach
p = 7  # 7-sided polygons
q = 3  # 3 meeting at each vertex
depth = 3

print(f"Creating {{7,3}} tiling")

# Create tile generator using q directly
# This should give us the correct hyperbolic heptagons
t_gen = htiles.TileGen.make_regular(p, q=q, skip=1)

# Create simple layout
t_layout = htiles.TileLayout()
t_layout.add_generator(t_gen, [0]*p, None)

# Generate tiles
# Rotate so heptagon has flat bottom (point up)
# For a heptagon, we need to rotate by 90 - 180/7 degrees
rotation = 90 - 180/7
start_tile = t_layout.start_tile(code=0, rotate_deg=rotation)
tiles = t_layout.tile_plane(start_tile, depth=depth)

print(f"Generated {len(tiles)} tiles")

# Create drawing
d = Drawing(2, 2, origin='center')

# No background circle - just start with tiles

# Color scheme inspired by Wikipedia
colors = {
    0: '#ff6b6b',      # Red for center
    1: '#4ecdc4',      # Teal for first ring
    2: '#45b7d1',      # Blue
    3: '#96ceb4',      # Green
    4: '#dfe6e9',      # Light gray
}

# Draw tiles
for i, tile in enumerate(tiles):
    if i == 0:
        color = colors[0]
    elif i < 8:
        color = colors[1]
    elif i < 30:
        color = colors[2]
    elif i < 100:
        color = colors[3]
    else:
        color = colors[4]
    
    # Draw with thin black borders
    d.draw(tile, fill=color, stroke='black', stroke_width=0.0015, opacity=0.9)

# No vertex dots - clean tiling only

# Save
d.set_render_size(w=800)
d.save_svg('view/hyperbolic_7_3_tiling.svg')

# Try to save PNG
try:
    d.save_png('view/hyperbolic_7_3_tiling.png')
    print("Saved as view/hyperbolic_7_3_tiling.svg and view/hyperbolic_7_3_tiling.png")
except ImportError as e:
    print(f"Saved as view/hyperbolic_7_3_tiling.svg (PNG export failed: {e})")

That looks like this:

But trying to get it to creating the 7 zigzag rays, these are 4 out of 20+ attempts so far:

ClaudeCode getting progressively worse each time, starting from the initial code above.

Any ideas how to accomplish this, either in code or conceptually / theory-wise?

[lancejpollard]

Many more iterations later, just trying to do an edge-thickening based approach, Claude having hard time knowing what I mean saying "now from the tip of that edge you just made thick, draw a new thick edge jutting out from that tip to the left" haha. But here is this:

import math
import drawsvg as draw
from drawsvg import Drawing
from hyperbolic import euclid
from hyperbolic.poincare import *
import hyperbolic.tiles as htiles

# Create {7,3} tiling
p = 7  # 7-sided polygons
q = 3  # 3 meeting at each vertex
depth = 4

print(f"Creating {7,3} tiling with connected ray pattern")

# Create tile generator using q directly
t_gen = htiles.TileGen.make_regular(p, q=q, skip=1)

# Create simple layout
t_layout = htiles.TileLayout()
t_layout.add_generator(t_gen, [0]*p, None)

# Generate tiles
# Rotate so heptagon has flat bottom (point up)
rotation = 90 - 180/7
start_tile = t_layout.start_tile(code=0, rotate_deg=rotation)
tiles = t_layout.tile_plane(start_tile, depth=depth)

print(f"Generated {len(tiles)} tiles")

# Create drawing
d = Drawing(2, 2, origin='center')

# Store all tile vertices for comparison
all_tile_vertices = []
for i, tile in enumerate(tiles):
    polygon = tile.to_polygon()
    vertices = list(polygon.vertices)
    all_tile_vertices.append((i, vertices))

# Function to check if two vertices are the same (within tolerance)
def vertices_match(v1, v2, tolerance=0.001):
    return abs(v1.x - v2.x) < tolerance and abs(v1.y - v2.y) < tolerance

# Function to find edges that share a vertex with a given point
def find_edges_with_vertex(tile_idx, vertices, target_vertex):
    """Find which edges of a tile contain a specific vertex"""
    matching_edges = []
    for i in range(len(vertices)):
        v1 = vertices[i]
        v2 = vertices[(i + 1) % len(vertices)]
        if vertices_match(v1, target_vertex) or vertices_match(v2, target_vertex):
            matching_edges.append(i)
    return matching_edges

# Function to check if an edge touches the center tile
def find_center_touching_edge(tile_index, vertices):
    """For tiles 1-7, find which edge index touches the center"""
    if tile_index < 1 or tile_index > 7:
        return -1
    
    min_dist = float('inf')
    center_edge_idx = -1
    
    for i in range(len(vertices)):
        v1 = vertices[i]
        v2 = vertices[(i + 1) % len(vertices)]
        mid_x = (v1.x + v2.x) / 2
        mid_y = (v1.y + v2.y) / 2
        edge_dist = math.sqrt(mid_x**2 + mid_y**2)
        
        if edge_dist < min_dist:
            min_dist = edge_dist
            center_edge_idx = i
    
    return center_edge_idx

# Find the endpoints of thick edges from layer 1
# These are the "tips" where we need to continue the rays
ray_tips = []
for i in range(1, 8):  # Tiles 1-7
    vertices = all_tile_vertices[i][1]
    center_edge = find_center_touching_edge(i, vertices)
    if center_edge >= 0:
        # The clockwise edge is (center_edge + 1) % 7
        clockwise_edge = (center_edge + 1) % 7
        # The tip is the second vertex of the clockwise edge
        tip_vertex = vertices[(clockwise_edge + 1) % 7]
        ray_tips.append((i, tip_vertex))

# First pass: Draw all filled polygons
for i, tile in enumerate(tiles):
    polygon = tile.to_polygon()
    d.draw(polygon, fill='#cccccc', stroke='none')

# Second pass: Draw all strokes on top
for i, tile in enumerate(tiles):
    polygon = tile.to_polygon()
    vertices = list(polygon.vertices)
    n = len(vertices)
    
    # Track which edges should be thick
    thick_edges = set()
    
    # Center tile - all edges thick
    if i == 0:
        thick_edges = set(range(n))
    
    # Layer 1 tiles - center edge and clockwise edge
    elif 1 <= i <= 7:
        center_edge = find_center_touching_edge(i, vertices)
        if center_edge >= 0:
            thick_edges.add(center_edge)
            thick_edges.add((center_edge + 1) % n)
    
    # Other tiles - check if they connect to ray tips
    else:
        for source_tile_idx, tip_vertex in ray_tips:
            # Check if this tile has any edges that include the tip vertex
            matching_edges = find_edges_with_vertex(i, vertices, tip_vertex)
            
            if matching_edges:
                # We found edges that touch a ray tip
                # We want the edge that goes "to the right" (clockwise from the incoming ray)
                for edge_idx in matching_edges:
                    v1 = vertices[edge_idx]
                    v2 = vertices[(edge_idx + 1) % n]
                    
                    # Only add this edge if it's going away from the source tile
                    # (i.e., it's the continuation of the ray, not going back)
                    if vertices_match(v1, tip_vertex):
                        # This edge starts at the tip and goes somewhere else
                        # Check if it's going "outward" (away from center)
                        mid_x = (v1.x + v2.x) / 2
                        mid_y = (v1.y + v2.y) / 2
                        if mid_x**2 + mid_y**2 > tip_vertex.x**2 + tip_vertex.y**2:
                            thick_edges.add(edge_idx)
                            break  # Only add one edge per ray tip
    
    # Draw edges individually
    for j in range(n):
        v1 = vertices[j]
        v2 = vertices[(j + 1) % n]
        
        # Determine stroke width
        stroke_width = 0.025 if j in thick_edges else 0.001
        
        # Draw the edge
        path = draw.Path(stroke='black', stroke_width=stroke_width, fill='none', stroke_linecap='round')
        path.M(v1.x, v1.y)
        path.L(v2.x, v2.y)
        d.append(path)

# Save
d.set_render_size(w=800)
d.save_svg('view/hyperbolic_7_3_rays.svg')

# Try to save PNG
try:
    d.save_png('view/hyperbolic_7_3_rays.png')
    print("Saved as view/hyperbolic_7_3_rays.svg and view/hyperbolic_7_3_rays.png")
except ImportError as e:
    print(f"Saved as view/hyperbolic_7_3_rays.svg (PNG export failed: {e})")

I would much prefer somehow adjusting the polygon dimensions to accommodate a gap, that way 1 side of the polygon is not shorter than the others due to this edge-thickening approach. But no idea how to do that.

[cduck]

Hi @lancejpollard,
Shrinking the polygons won't work because in hyperbolic geometry shrinking a polygon changes its angles and they won't tile properly.

Instead, try moving the seven groups of polygons radially outward. Due to how the Poincaré projection works, all the tiles will still be drawn within the same unit circle.

I suggest first creating the standard tiling which gives you a list of all the tiles, then write some code to group the tiles by radial position into seven groups. Finally apply a translation transform to each tile (except the center tile); each tile in a group should get the same translation so there are no gaps between tiles in the same group.