multi-puzzle-solver 0.9.18__py3-none-any.whl → 0.9.22__py3-none-any.whl

puzzle_solver/puzzles/norinori/norinori.py

@@ -1,133 +1,32 @@
-import json
-import time
 from dataclasses import dataclass
-from typing import Optional, Union
 
-from ortools.sat.python import cp_model
 import numpy as np
+from ortools.sat.python import cp_model
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
-
-
-# a shape on the 2d board is just a set of positions
-Shape = frozenset[Pos]
-
-
-def polyominoes(N):
-    """Generate all polyominoes of size N. Every rotation and reflection is considered different and included in the result.
-    Translation is not considered different and is removed from the result (otherwise the result would be infinite).
-
-    Below is the number of unique polyominoes of size N (not including rotations and reflections) and the lenth of the returned result (which includes all rotations and reflections)
-    N	name		#shapes		#results
-    1	monomino	1			1
-    2	domino		1			2
-    3	tromino		2			6
-    4	tetromino	5			19
-    5	pentomino	12			63
-    6	hexomino	35			216
-    7	heptomino	108			760
-    8	octomino	369			2,725
-    9	nonomino	1,285		9,910
-    10	decomino	4,655		36,446
-    11	undecomino	17,073		135,268
-    12	dodecomino	63,600		505,861
-    Source: https://en.wikipedia.org/wiki/Polyomino
-
-    Args:
-        N (int): The size of the polyominoes to generate.
-
-    Returns:
-        set[(frozenset[Pos], int)]: A set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino.
-    """
-    assert N >= 1, 'N cannot be less than 1'
-    # need a frozenset because regular sets are not hashable
-    shapes: set[Shape] = {frozenset({Pos(0, 0)})}
-    for i in range(1, N):
-        next_shapes: set[Shape] = set()
-        for s in shapes:
-            # frontier: all 4-neighbors of existing cells not already in the shape
-            frontier = {get_next_pos(pos, direction)
-                        for pos in s
-                        for direction in Direction
-                        if get_next_pos(pos, direction) not in s}
-            for cell in frontier:
-                t = s | {cell}
-                # normalize by translation only: shift so min x,y is (0,0). This removes translational symmetries.
-                minx = min(pos.x for pos in t)
-                miny = min(pos.y for pos in t)
-                t0 = frozenset(Pos(x=pos.x - minx, y=pos.y - miny) for pos in t)
-                next_shapes.add(t0)
-        shapes = next_shapes
-    # shapes is now complete, now classify up to D4 symmetry (rotations/reflections), translations ignored
-    mats = (
-        ( 1, 0,  0, 1),  # regular
-        (-1, 0,  0, 1),  # reflect about x
-        ( 1, 0,  0,-1),  # reflect about y
-        (-1, 0,  0,-1),  # reflect about x and y
-        # trnaspose then all 4 above
-        ( 0, 1,  1, 0), ( 0, 1, -1, 0), ( 0,-1,  1, 0), ( 0,-1, -1, 0),
-    )
-    # compute canonical representative for each shape (lexicographically smallest normalized transform)
-    shape_to_canon: dict[Shape, tuple[Pos, ...]] = {}
-    for s in shapes:
-        reps: list[tuple[Pos, ...]] = []
-        for a, b, c, d in mats:
-            pts = {Pos(x=a*p.x + b*p.y, y=c*p.x + d*p.y) for p in s}
-            minx = min(p.x for p in pts)
-            miny = min(p.y for p in pts)
-            rep = tuple(sorted(Pos(x=p.x - minx, y=p.y - miny) for p in pts))
-            reps.append(rep)
-        canon = min(reps)
-        shape_to_canon[s] = canon
-
-    canon_set = set(shape_to_canon.values())
-    canon_to_id = {canon: i for i, canon in enumerate(sorted(canon_set))}
-    result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
-    return result
-
-
-@dataclass(frozen=True)
-class SingleSolution:
-    assignment: dict[Pos, Union[str, int]]
-    all_other_variables: dict
-
-    def get_hashable_solution(self) -> str:
-        result = []
-        for pos, v in self.assignment.items():
-            result.append((pos.x, pos.y, v))
-        return json.dumps(result, sort_keys=True)
-
+from puzzle_solver.core.utils import Pos, Shape, get_all_pos, get_char, set_char, polyominoes, in_bounds, get_next_pos, Direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
 
 
 @dataclass
 class ShapeOnBoard:
     is_active: cp_model.IntVar
-    shape: Shape
-    shape_id: int
+    orientation: str
     body: set[Pos]
-    disallow_same_shape: set[Pos]
+    disallow: set[Pos]
 
 
 class Board:
-    def __init__(self, board: np.array, polyomino_degrees: int = 4):
+    def __init__(self, board: np.ndarray):
         assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
-        self.V = board.shape[0]
-        self.H = board.shape[1]
-        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
         self.board = board
-        self.polyomino_degrees = polyomino_degrees
-        self.polyominoes = polyominoes(self.polyomino_degrees)
-
+        self.V, self.H = board.shape
+        assert all((c == ' ') or str(c).isdecimal() for c in np.nditer(board)), "board must contain space or digits"
         self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
-        self.blocks = {i: set() for i in self.block_numbers}
-        for cell in get_all_pos(self.V, self.H):
-            self.blocks[int(get_char(self.board, cell))].add(cell)
+        self.blocks = {i: [pos for pos in get_all_pos(self.V, self.H) if int(get_char(self.board, pos)) == i] for i in self.block_numbers}
 
         self.model = cp_model.CpModel()
         self.model_vars: dict[Pos, cp_model.IntVar] = {}
-        self.connected_components: dict[Pos, cp_model.IntVar] = {}
-        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.shapes_on_board: list[ShapeOnBoard] = []
 
         self.create_vars()
         self.init_shapes_on_board()
@@ -136,120 +35,67 @@ class Board:
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
             self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
-        # print('base vars:', len(self.model_vars))
 
     def init_shapes_on_board(self):
-        for idx, (shape, shape_id) in enumerate(self.polyominoes):
-            for translate in get_all_pos(self.V, self.H):  # body of shape is translated to be at pos
-                body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape}
-                if any(not in_bounds(p, self.V, self.H) for p in body):
-                    continue
-                # shape must be fully contained in one block
-                if len(set(get_char(self.board, p) for p in body)) > 1:
-                    continue
-                # 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
-                disallow_same_shape = set(get_next_pos(p, direction) for p in body for direction in Direction)
-                disallow_same_shape -= body
-                self.shapes_on_board.append(ShapeOnBoard(
-                    is_active=self.model.NewBoolVar(f'{idx}:{translate}:is_active'),
-                    shape=shape,
-                    shape_id=shape_id,
-                    body=body,
-                    disallow_same_shape=disallow_same_shape,
-                ))
-        # print('shapes on board:', len(self.shapes_on_board))
+        for pos in get_all_pos(self.V, self.H):
+            shape = self.get_shape(pos, 'horizontal')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
+            shape = self.get_shape(pos, 'vertical')
+            if shape is not None:
+                self.shapes_on_board.append(shape)
 
     def add_all_constraints(self):
-        # RULES:
-        # 1- You have to place one tetromino in each region in such a way that:
-        # 2- 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
-        # 3- The shaded cells should form a single connected area.
-        # 4- 2x2 shaded areas are not allowed
-
-        # each cell must be part of a shape, every shape must be fully on the board. Core constraint, otherwise shapes on the board make no sense.
-        self.only_allow_shapes_on_board()
-
-        self.force_one_shape_per_block()  # Rule #1
-        self.disallow_same_shape_touching()  # Rule #2
-        self.fc = force_connected_component(self.model, self.model_vars)  # Rule #3
-        # print('force connected vars:', len(fc))
-        shape_2_by_2 = frozenset({Pos(0, 0), Pos(0, 1), Pos(1, 0), Pos(1, 1)})
-        self.disallow_shape(shape_2_by_2)  # Rule #4
-
-
-    def only_allow_shapes_on_board(self):
-        for shape_on_board in self.shapes_on_board:
-            # if shape is active then all its body cells must be active
-            self.model.Add(sum(self.model_vars[p] for p in shape_on_board.body) == len(shape_on_board.body)).OnlyEnforceIf(shape_on_board.is_active)
-        # each cell must be part of a shape
-        for p in get_all_pos(self.V, self.H):
-            shapes_on_p = [s for s in self.shapes_on_board if p in s.body]
-            self.model.Add(sum(s.is_active for s in shapes_on_p) == 1).OnlyEnforceIf(self.model_vars[p])
-
-    def force_one_shape_per_block(self):
-        # You have to place exactly one tetromino in each region
-        for block_i in self.block_numbers:
-            shapes_on_block = [s for s in self.shapes_on_board if s.body & self.blocks[block_i]]
-            assert all(s.body.issubset(self.blocks[block_i]) for s in shapes_on_block), 'expected all shapes on block to be fully contained in the block'
-            # print(f'shapes on block {block_i} has {len(shapes_on_block)} shapes')
-            self.model.Add(sum(s.is_active for s in shapes_on_block) == 1)
-
-    def disallow_same_shape_touching(self):
-        # if shape is active then it must not touch any other shape of the same type
-        for shape_on_board in self.shapes_on_board:
-            similar_shapes = [s for s in self.shapes_on_board if s.shape_id == shape_on_board.shape_id]
-            for s in similar_shapes:
-                if shape_on_board.disallow_same_shape & s.body:  # this shape disallows having s be on the board
-                    self.model.Add(s.is_active == 0).OnlyEnforceIf(shape_on_board.is_active)
-
-    def disallow_shape(self, shape_to_disallow: Shape):
-        # for every position in the board, force sum of body < len(body)
-        for translate in get_all_pos(self.V, self.H):
-            cur_body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape_to_disallow}
-            if any(not in_bounds(p, self.V, self.H) for p in cur_body):
-                continue
-            self.model.Add(sum(self.model_vars[p] for p in cur_body) < len(cur_body))
-
-
-
-
-    def solve_and_print(self, verbose: bool = True, max_solutions: Optional[int] = None, verbose_callback: Optional[bool] = None):
-        if verbose_callback is None:
-            verbose_callback = verbose
-        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+        # if a piece is active then all its body is active and the disallow is inactive
+        for shape in self.shapes_on_board:
+            for pos in shape.body:
+                self.model.Add(self.model_vars[pos] == 1).OnlyEnforceIf(shape.is_active)
+            for pos in shape.disallow:
+                self.model.Add(self.model_vars[pos] == 0).OnlyEnforceIf(shape.is_active)
+        # if a spot is active then exactly one piece (with a body there) is active
+        for pos in get_all_pos(self.V, self.H):
+            pieces_on_pos = [shape for shape in self.shapes_on_board if pos in shape.body]
+            # if pos is on then exactly one shape is active. if pos is off then 0 shapes are active.
+            self.model.Add(sum(shape.is_active for shape in pieces_on_pos) == self.model_vars[pos])
+        # every region must have exactly 2 spots active.
+        for block in self.blocks.values():
+            self.model.Add(sum(self.model_vars[pos] for pos in block) == 2)
+
+    def get_shape(self, pos: Pos, orientation: str) -> Shape:
+        assert orientation in ['horizontal', 'vertical'], 'orientation must be horizontal or vertical'
+        if orientation == 'horizontal':
+            body = {pos, get_next_pos(pos, Direction.RIGHT)}
+        else:
+            body = {pos, get_next_pos(pos, Direction.DOWN)}
+        if any(not in_bounds(p, self.V, self.H) for p in body):
+            return None
+        disallow = set(get_next_pos(p, direction) for p in body for direction in Direction)
+        disallow = {p for p in disallow if p not in body and in_bounds(p, self.V, self.H)}
+        shape_on_board = ShapeOnBoard(
+            is_active=self.model.NewBoolVar(f'horizontal:{pos}'),
+            orientation='horizontal',
+            body=body,
+            disallow=disallow,
+        )
+        return shape_on_board
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: "Board", solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
             assignment: dict[Pos, int] = {}
-            for pos, var in board.model_vars.items():
-                assignment[pos] = solver.Value(var)
-            all_other_variables = {
-                'fc': {k: solver.Value(v) for k, v in board.fc.items()}
-            }
-            return SingleSolution(assignment=assignment, all_other_variables=all_other_variables)
+            for pos in get_all_pos(self.V, self.H):
+                if solver.Value(self.model_vars[pos]) == 1:
+                    assignment[pos] = get_char(self.board, pos)
+            return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
-            res = np.full((self.V, self.H), ' ', dtype=str)
-            for pos, val in single_res.assignment.items():
-                c = 'X' if val == 1 else ' '
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos)
+                c = 'X' if pos in single_res.assignment else ' '
                 set_char(res, pos, c)
-            print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
-            pass
-        return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)
-
-    def solve_then_constrain(self, verbose: bool = True):
-        tic = time.time()
-        all_solutions = []
-        while True:
-            solutions = self.solve_and_print(verbose=False, verbose_callback=verbose, max_solutions=1)
-            if len(solutions) == 0:
-                break
-            all_solutions.extend(solutions)
-            assignment = solutions[0].assignment
-            # constrain the board to not return the same solution again
-            lits = [self.model_vars[p].Not() if assignment[p] == 1 else self.model_vars[p] for p in assignment.keys()]
-            self.model.AddBoolOr(lits)
-            self.model.ClearHints()
-            for k, v in solutions[0].all_other_variables['fc'].items():
-                self.model.AddHint(self.fc[k], v)
-        print(f'Solutions found: {len(all_solutions)}')
-        toc = time.time()
-        print(f'Time taken: {toc - tic:.2f} seconds')
-        return all_solutions
+            print('[')
+            for row in res:
+                print("    [ '" + "', '".join(row.tolist()) + "' ],")
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -0,0 +1,248 @@
+import numpy as np
+from collections import defaultdict
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+CellBorder = tuple[Pos, Direction]
+Corner = Pos
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() == ' ' or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only spaces or digits'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.board = board
+        self.cell_borders_to_corners: dict[CellBorder, set[Corner]] = defaultdict(set)  # for every cell border, a set of all corners it is connected to
+        self.corners_to_cell_borders: dict[Corner, set[CellBorder]] = defaultdict(set)  # opposite direction
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[CellBorder, cp_model.IntVar] = {}  # one entry for every unique variable in the model
+        self.cell_borders: dict[CellBorder, cp_model.IntVar] = {}  # for every position and direction, one entry for that edge (thus the same edge variables are used in opposite directions of neighboring cells)
+        self.corner_vars: dict[Corner, set[cp_model.IntVar]] = defaultdict(set)  # for every corner, one entry for each edge that touches the corner (i.e. 4 per corner unless on the border)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                self.add_var(pos, direction)
+        for pos in get_row_pos(0, self.H):
+            self.add_var(pos, Direction.UP)
+        for pos in get_col_pos(0, self.V):
+            self.add_var(pos, Direction.LEFT)
+
+    def add_var(self, pos: Pos, direction: Direction):
+        cell_border = (pos, direction)
+        v = self.model.NewBoolVar(f'main:{cell_border}')
+        self.model_vars[cell_border] = v
+        self.add_cell_border_var(cell_border, v)
+        self.add_corner_vars(cell_border, v)
+
+    def add_cell_border_var(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """An edge belongs to two cells unless its on the border in which case it only belongs to one."""
+        pos, direction = cell_border
+        self.cell_borders[cell_border] = var
+        next_pos = get_next_pos(pos, direction)
+        if in_bounds(next_pos, self.V, self.H):
+            self.cell_borders[(next_pos, get_opposite_direction(direction))] = var
+    
+    def add_corner_vars(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """
+        An edge always belongs to two corners. Note that the cell xi,yi has the 4 corners (xi,yi), (xi+1,yi), (xi,yi+1), (xi+1,yi+1). (memorize these 4 coordinates or the function wont make sense)
+        Thus corner index is +1 of board coordinates.
+        Never check for bounds here because an edge ALWAYS touches two corners AND because the +1 will make in_bounds return False when its still in bounds.
+        """
+        pos, direction = cell_border
+        if direction == Direction.LEFT:  # it touches me and (xi,yi+1)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.DOWN)
+        elif direction == Direction.UP:  # it touches me and (xi+1,yi)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.RIGHT)
+        elif direction == Direction.RIGHT:  # it touches (xi+1,yi) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.RIGHT)
+            corner2 = get_next_pos(corner1, Direction.DOWN)
+        elif direction == Direction.DOWN:  # it touches (xi,yi+1) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.DOWN)
+            corner2 = get_next_pos(corner1, Direction.RIGHT)
+        else:
+            raise ValueError(f'Invalid direction: {direction}')
+        self.corner_vars[corner1].add(var)
+        self.corner_vars[corner2].add(var)
+        self.cell_borders_to_corners[cell_border].add(corner1)
+        self.cell_borders_to_corners[cell_border].add(corner2)
+        self.corners_to_cell_borders[corner1].add(cell_border)
+        self.corners_to_cell_borders[corner2].add(cell_border)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # enforce cells with numbers
+            variables = [self.cell_borders[(pos, direction)] for direction in Direction if (pos, direction) in self.cell_borders]
+            val = get_char(self.board, pos)
+            if not val.isdecimal():
+                continue
+            self.model.Add(sum(variables) == int(val))
+        for corner in self.corner_vars:  # a corder always has 0 or 2 active edges
+            g = self.model.NewBoolVar(f'corner_gate_{corner}')
+            self.model.Add(sum(self.corner_vars[corner]) == 0).OnlyEnforceIf(g.Not())
+            self.model.Add(sum(self.corner_vars[corner]) == 2).OnlyEnforceIf(g)
+        # single connected component
+        def is_neighbor(cb1: CellBorder, cb2: CellBorder) -> bool:
+            cb1_corners = self.cell_borders_to_corners[cb1]
+            cb2_corners = self.cell_borders_to_corners[cb2]
+            return len(cb1_corners & cb2_corners) > 0
+        force_connected_component(self.model, self.model_vars, is_neighbor=is_neighbor)
+
+
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, direction), var in board.model_vars.items():
+                if solver.value(var) == 1:
+                    if pos not in assignment:
+                        assignment[pos] = ''
+                    assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if pos not in single_res.assignment:
+                    continue
+                c = ''.join(sorted(single_res.assignment[pos]))
+                set_char(res, pos, c)
+            print(render_grid(cell_flags=res, center_char=lambda c, r: self.board[r, c] if self.board[r, c] != ' ' else '·'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=999)
+
+
+
+
+
+def render_grid(cell_flags: np.ndarray = None,
+                H: np.ndarray = None,
+                V: np.ndarray = None,
+                mark_centers: bool = True,
+                center_char: str = '·',
+                show_axes: bool = True,
+                scale_x: int = 2) -> str:
+    """
+    AI generated this because I don't currently care about the details of rendering to the terminal and I did it in a quick and dirty way while the AI made it in a pretty way, and this looks good during my development.
+        cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    OR:
+        H: (N+1, N) horizontal edges between corners
+        V: (N,   N+1) vertical edges between corners
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    if cell_flags is not None:
+        N = cell_flags.shape[0]
+        H = np.zeros((N+1, N), dtype=bool)
+        V = np.zeros((N, N+1), dtype=bool)
+        for r in range(N):
+            for c in range(N):
+                s = cell_flags[r, c]
+                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
+                if 'D' in s: H[r+1, c] = True          # edge below the cell
+                if 'L' in s: V[r, c]   = True          # edge left of the cell
+                if 'R' in s: V[r, c+1] = True          # edge right of the cell
+    assert H is not None and V is not None, 'H and V must be provided'
+    # Bitmask for corner connections
+    U, R, D, L = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        L: '─', R: '─', L|R: '─',
+        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
+        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
+        U|R|D|L: '┼',
+    }
+
+    assert scale_x >= 1
+    N = V.shape[0]
+    assert H.shape == (N+1, N) and V.shape == (N, N+1)
+
+    rows = 2*N + 1
+    cols = 2*N*scale_x + 1                 # stretched width
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N):
+            if H[r, c]:
+                # previously: for k in range(1, scale_x*2, 2):
+                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: draw at the corner columns (no horizontal stretching needed)
+    for r in range(N):
+        rr = 2*r + 1
+        for c in range(N+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at corners
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < N   and H[r, c]:   m |= R
+            if r < N   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= L
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers (help count exact widths/heights)
+    if mark_centers:
+        for r in range(N):
+            rr = 2*r + 1
+            for c in range(N):
+                # center lies midway across the stretched span
+                xc = x_corner(c) + scale_x          # middle-ish; works for any integer scale_x
+                canvas[rr][xc] = center_char if isinstance(center_char, str) else center_char(c, r)
+
+    # turn canvas rows into strings
+    art_rows = [''.join(row) for row in canvas]
+
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # ── Axes ────────────────────────────────────────────────────────────────
+    gut = max(2, len(str(N-1)))       # left gutter width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(N):
+        xc_center = x_corner(c) + scale_x
+        if N >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    # tiny corner labels
+    if gut >= 2:
+        top_tens[gut-2:gut] = list('  ')
+        top_ones[gut-2:gut] = list('  ')
+
+    labeled = []
+    for r, line in enumerate(art_rows):
+        if r % 2 == 1:                     # cell-center row
+            label = str(r//2).rjust(gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -3,6 +3,7 @@
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
+# import json
 from pathlib import Path
 import numpy as np
 cv = None
@@ -72,6 +73,8 @@ def mean_consecutives(arr: np.ndarray) -> np.ndarray:
     return np.array(sums) // np.array(counts)
 
 def dfs(x, y, out, output, current_num):
+    # if current_num == '48':
+    #     print('dfs', x, y, current_num)
     if x < 0 or x >= out.shape[1] or y < 0 or y >= out.shape[0]:
         return
     if out[y, x] != '  ':
@@ -136,6 +139,8 @@ def main(image):
             cell = src[hidx1:hidx2, vidx1:vidx2]
             mid_x = cell.shape[1] // 2
             mid_y = cell.shape[0] // 2
+            # if j > height - 4 and i > width - 6:
+            #     show_wait_destroy(f"cell_{i}_{j}", cell)
             # show_wait_destroy(f"cell_{i}_{j}", cell)
             cell = cv.bitwise_not(cell)  # invert colors
             top = cell[0:10, mid_y-5:mid_y+5]
@@ -156,10 +161,18 @@ def main(image):
     axs[1, 0].set_title('Right')
     axs[1, 1].hist(list(hists['bottom'].values()), bins=100)
     axs[1, 1].set_title('Bottom')
+    global_target = None
+    # global_target = 28_000
     target_top = np.mean(list(hists['top'].values()))
     target_left = np.mean(list(hists['left'].values()))
     target_right = np.mean(list(hists['right'].values()))
     target_bottom = np.mean(list(hists['bottom'].values()))
+    if global_target is not None:
+        target_top = global_target
+        target_left = global_target
+        target_right = global_target
+        target_bottom = global_target
+
     axs[0, 0].axvline(target_top, color='red')
     axs[0, 1].axvline(target_left, color='red')
     axs[1, 0].axvline(target_right, color='red')
@@ -185,12 +198,18 @@ def main(image):
             print('   Sums: ', hists['top'][j, i], hists['left'][j, i], hists['right'][j, i], hists['bottom'][j, i])
 
     current_count = 0
-    out = np.full_like(output['top'], '  ', dtype='U2')
+    z_fill = 2
+    out = np.full_like(output['top'], '  ', dtype='U32')
     for j in range(out.shape[0]):
+        if current_count > 99:
+            z_fill = 3
         for i in range(out.shape[1]):
             if out[j, i] == '  ':
-                dfs(i, j, out, output, str(current_count).zfill(2))
+                if current_count == 48:
+                    print(f"current_count: {current_count}, x: {i}, y: {j}")
+                dfs(i, j, out, output, str(current_count).zfill(z_fill))
                 current_count += 1
+    print(out)
 
     with open(output_path, 'w') as f:
         f.write('[\n')
@@ -202,6 +221,18 @@ def main(image):
         f.write(']')
     print('output json: ', output_path)
 
+    # with open(output_path.parent / 'debug.json', 'w') as f:
+    #     debug_pos = {}
+    #     for j in range(out.shape[0]):
+    #         for i in range(out.shape[1]):
+    #             out_str = ''
+    #             out_str += 'T' if output['top'][j, i] else ''
+    #             out_str += 'L' if output['left'][j, i] else ''
+    #             out_str += 'R' if output['right'][j, i] else ''
+    #             out_str += 'B' if output['bottom'][j, i] else ''
+    #             debug_pos[f'{j}_{i}'] = out_str
+    #     json.dump(debug_pos, f, indent=2)
+
 if __name__ == '__main__':
     # to run this script and visualize the output, in the root run:
     #  python .\src\puzzle_solver\puzzles\stitches\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
@@ -209,4 +240,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'weekly_oct_3rd_2025.png')
     # main(Path(__file__).parent / 'input_output' / 'star_battle_67f73ff90cd8cdb4b3e30f56f5261f4968f5dac940bc6.png')
     # main(Path(__file__).parent / 'input_output' / 'LITS_MDoxNzksNzY3.png')
-    main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
+    main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')