multi-puzzle-solver 1.1.8__py3-none-any.whl

puzzle_solver/puzzles/snail/snail.py

@@ -0,0 +1,97 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_pos, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def spiral_from_topleft(matrix, N: int):
+    res = []
+    top, bottom = 0, N - 1
+    left, right = 0, N - 1
+    while top <= bottom and left <= right:
+        for c in range(left, right + 1):  # go right
+            res.append(matrix[get_pos(x=c, y=top)])
+        top += 1
+        if top > bottom:
+            break
+        for r in range(top, bottom + 1):  # go down
+            res.append(matrix[get_pos(x=right, y=r)])
+        right -= 1
+        if left > right:
+            break
+        for c in range(right, left - 1, -1):  # go left
+            res.append(matrix[get_pos(x=c, y=bottom)])
+        bottom -= 1
+        if top > bottom:
+            break
+        for r in range(bottom, top - 1, -1):  # go up
+            res.append(matrix[get_pos(x=left, y=r)])
+        left += 1
+    return res
+
+
+def get_eq_val(model: cp_model.CpModel, int_var: cp_model.IntVar, val: int) -> cp_model.IntVar:
+    eq_var = model.NewBoolVar(f'{int_var}:{val}:eq')
+    model.Add(int_var == val).OnlyEnforceIf(eq_var)
+    model.Add(int_var != val).OnlyEnforceIf(eq_var.Not())
+    return eq_var
+
+
+class Board:
+    def __init__(self, board: np.array):
+        self.V, self.H = board.shape
+        assert self.V == self.H and self.V >= 3, f'board must be square, got {self.V}x{self.H}'
+        self.board = board
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewIntVar(0, 4, f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos).strip()
+            if c:
+                self.model.Add(self.model_vars[pos] == int(c))
+        for v in [1, 2, 3]:
+            for row in range(self.V):
+                self.model.AddExactlyOne([get_eq_val(self.model, self.model_vars[pos], v) for pos in get_row_pos(row, self.H)])
+            for col in range(self.H):
+                self.model.AddExactlyOne([get_eq_val(self.model, self.model_vars[pos], v) for pos in get_col_pos(col, self.V)])
+        vars_ = spiral_from_topleft(self.model_vars, self.V)
+        self.add_snail_pattern(vars_)
+
+    def add_snail_pattern(self, vars_):
+        """Enforce on vars_ (each in {0,1,2,3}) that, ignoring 0s, the nonzero values must follow the repeating pattern 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> ..."""
+        # States: 0 = expect 1, 1 = expect 2, 2 = expect 3
+        start = 0
+        accept = [3]  # we can stop after expecting 1 or 2 or 3
+        transitions = [ #  (*tail*, *transition*, *head*)
+            # zeros don't change the state
+            (0, 0, 0),
+            (1, 0, 1),
+            (2, 0, 2),
+            (3, 0, 3),
+            # pattern 1 -> 2 -> 3 -> 1 ...
+            (0, 1, 1),  # State 0: saw "1" -> Go to state 1 (which will expect 2)
+            (1, 2, 2),  # State 1: saw "2" -> Go to state 2 (which will expect 3)
+            (2, 3, 3),  # State 2: saw "3" -> Go to state 3 (which will expect 1)
+            (3, 1, 1),  # State 3: saw "1" -> Go to state 1 (which will expect 2)
+        ]
+        self.model.AddAutomaton(vars_, start, accept, transitions)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(v) for pos, v in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]).replace('0', ' '),
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/split_ends/split_ends.py

@@ -0,0 +1,93 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, get_char, get_pos, get_row_pos, get_col_pos, Direction, get_next_pos, in_bounds
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() in ['L', 'R', 'U', 'D', 'O', ' '] for c in np.nditer(board)), 'board must contain only L, R, U, D, O, or space'
+        self.STATES = list(Direction) + ['O']
+        self.board = board
+        self.V, self.H = board.shape
+        assert self.V == 6 and self.H == 6, f'board must be 6x6, got {self.V}x{self.H}'
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in self.STATES:
+                self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+            self.model.AddExactlyOne([self.model_vars[(pos, direction)] for direction in self.STATES])
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # force clues
+            c = get_char(self.board, pos)
+            c = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN, 'O': 'O'}.get(c, None)
+            if c is not None:
+                self.model.Add(self.model_vars[(pos, c)] == 1)
+        for row in range(self.V):  # each row, 1 of each direction and 2 O's
+            for direction in Direction:
+                self.model.AddExactlyOne([self.model_vars[(pos, direction)] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # each column, 1 of each direction and 2 O's
+            for direction in Direction:
+                self.model.AddExactlyOne([self.model_vars[(pos, direction)] for pos in get_col_pos(col, self.V)])
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                self.apply_orientation_rule(pos, direction)
+
+    def apply_orientation_rule(self, pos: Pos, direction: Direction):
+        # if cell is direction (for example L), then the cell to its left must not be R, and the cell to its up-right and down-right must also not be R
+        # and the cell to its up-right can't be U and the cell to its down-right can't be D. You have to see the triangles visually for it to make sense.
+        assert direction in Direction, f'direction must be in Direction, got {direction}'
+        if direction == Direction.LEFT:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.LEFT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.RIGHT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.UP),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.DOWN),
+            ]
+        elif direction == Direction.RIGHT:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.RIGHT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.UP),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.DOWN),
+            ]
+        elif direction == Direction.UP:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.UP), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.DOWN),
+                (get_next_pos(pos, Direction8.DOWN_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.DOWN_RIGHT), Direction.RIGHT),
+            ]
+        elif direction == Direction.DOWN:
+            disallow_pairs = [
+                (get_next_pos(pos, Direction8.DOWN), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.UP),
+                (get_next_pos(pos, Direction8.UP_LEFT), Direction.LEFT),
+                (get_next_pos(pos, Direction8.UP_RIGHT), Direction.RIGHT),
+            ]
+        else:
+            raise ValueError(f'invalid direction: {direction}')
+        disallow_pairs = [d_pair for d_pair in disallow_pairs if in_bounds(d_pair[0], self.V, self.H)]
+        for d_pos, d_direction in disallow_pairs:
+            self.model.Add(self.model_vars[(d_pos, d_direction)] == 0).OnlyEnforceIf(self.model_vars[(pos, direction)])
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: 'O' if direction == 'O' else direction.name[0] for (pos, direction), var in board.model_vars.items() if solver.Value(var) == 1})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ' ')))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/star_battle/star_battle.py

@@ -0,0 +1,75 @@
+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_neighbors8, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+class Board:
+    def __init__(self, board: np.array, star_count: int = 1, shapeless: bool = False):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert star_count >= 1 and isinstance(star_count, int), 'star_count must be an integer greater than or equal to 1'
+        self.board = board
+        self.V, self.H = board.shape
+        self.N = self.V * self.H
+        self.star_count = star_count
+        self.shapeless = shapeless
+        if not shapeless:
+            assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
+            self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
+            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}
+        else:
+            assert all((str(c.item()) in [' ', 'B'] for c in np.nditer(board))), 'board must contain only digits'
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        # N stars per row / column
+        for row in range(self.V):
+            self.model.Add(sum(self.model_vars[pos] for pos in get_row_pos(row, H=self.H)) == self.star_count)
+        for col in range(self.H):
+            self.model.Add(sum(self.model_vars[pos] for pos in get_col_pos(col, V=self.V)) == self.star_count)
+        if self.shapeless:  # shapeless version = no blocks but disallow black cells
+            for pos in get_all_pos(self.V, self.H):
+                if get_char(self.board, pos) == 'B':
+                    self.model.Add(self.model_vars[pos] == 0)
+        else:  # shaped version = blocks
+            for block_i in self.block_numbers:
+                self.model.Add(sum(self.model_vars[pos] for pos in self.blocks[block_i]) == self.star_count)
+        # stars can't be adjacent
+        for pos in get_all_pos(self.V, self.H):
+            for neighbor in get_neighbors8(pos, V=self.V, H=self.H):
+                self.model.Add(self.model_vars[neighbor] == 0).OnlyEnforceIf(self.model_vars[pos])
+
+
+    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)
+            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 single_res.assignment[pos] == 1:
+                    set_char(res, pos, 'X')
+                else:
+                    b = get_char(self.board, pos)
+                    if b == 'B':
+                        set_char(res, pos, ' ')
+                    else:
+                        set_char(res, pos, '.')
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
+                center_char=lambda r, c: res[r][c]
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/star_battle/star_battle_shapeless.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+from . import star_battle
+
+class Board(star_battle.Board):
+    def __init__(self, board: np.array, star_count: int = 1):
+        super().__init__(board=board, star_count=star_count, shapeless=True)

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -0,0 +1,267 @@
+"""
+    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file.
+    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
+Image = None
+
+
+def extract_lines(bw):
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 9
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+    horizontal_means = np.mean(horizontal, axis=1)
+    horizontal_cutoff = np.percentile(horizontal_means, 50)
+    # location where the horizontal lines are
+    horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
+    # print(f"horizontal_idx: {horizontal_idx}")
+    # height = len(horizontal_idx)
+    show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
+
+    rows = vertical.shape[0]
+    verticalsize = rows // 9
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+    vertical_means = np.mean(vertical, axis=0)
+    vertical_cutoff = np.percentile(vertical_means, 50)
+    vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
+    # print(f"vertical_idx: {vertical_idx}")
+    # width = len(vertical_idx)
+    # print(f"height: {height}, width: {width}")
+    # print(f"vertical_means: {vertical_means}")
+    show_wait_destroy("vertical", vertical)  # this has the vertical lines
+
+    vertical = cv.bitwise_not(vertical)
+    # show_wait_destroy("vertical_bit", vertical)
+
+    return horizontal_idx, vertical_idx
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def mean_consecutives(arr: np.ndarray) -> np.ndarray:
+    """if a sequence of values is consecutive, then average the values"""
+    sums = []
+    counts = []
+    for i in range(len(arr)):
+        if i == 0:
+            sums.append(arr[i])
+            counts.append(1)
+        elif arr[i] == arr[i-1] + 1:
+            sums[-1] += arr[i]
+            counts[-1] += 1
+        else:
+            sums.append(arr[i])
+            counts.append(1)
+    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] != '  ':
+        return
+    out[y, x] = current_num
+    if output['top'][y, x] == 0:
+        dfs(x, y-1, out, output, current_num)
+    if output['left'][y, x] == 0:
+        dfs(x-1, y, out, output, current_num)
+    if output['right'][y, x] == 0:
+        dfs(x+1, y, out, output, current_num)
+    if output['bottom'][y, x] == 0:
+        dfs(x, y+1, out, output, current_num)
+
+def main(image):
+    global Image
+    global cv
+    import matplotlib.pyplot as plt
+    from PIL import Image as Image_module
+    import cv2 as cv_module
+    Image = Image_module
+    cv = cv_module
+
+
+    image_path = Path(image)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(image, cv.IMREAD_COLOR)
+    assert src is not None, f'Error opening image: {image}. Parent exists: {image_path.parent.exists()}'
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+    # now the image is in grayscale
+
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # show_wait_destroy("binary", bw)
+
+    # show_wait_destroy("src", src)
+    horizontal_idx, vertical_idx = extract_lines(bw)
+    horizontal_idx = mean_consecutives(horizontal_idx)
+    vertical_idx = mean_consecutives(vertical_idx)
+    mean_vertical_dist = np.mean(np.diff(vertical_idx))
+    mean_horizontal_dist = np.mean(np.diff(horizontal_idx))
+    height = len(horizontal_idx)
+    width = len(vertical_idx)
+    print(f"height: {height}, width: {width}")
+    print(f"horizontal_idx: {horizontal_idx}")
+    print(f"vertical_idx: {vertical_idx}")
+    hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
+    j_idx = 0
+    i_len = 0
+    j_len = 0
+    for j in range(height - 1):
+        i_idx = 0
+        for i in range(width - 1):
+            hidx1, hidx2 = horizontal_idx[j], horizontal_idx[j+1]
+            vidx1, vidx2 = vertical_idx[i], vertical_idx[i+1]
+            hidx1 = max(0, hidx1 - 2)
+            hidx2 = min(src.shape[0], hidx2 + 4)
+            vidx1 = max(0, vidx1 - 2)
+            vidx2 = min(src.shape[1], vidx2 + 4)
+            if (hidx2 - hidx1) < mean_horizontal_dist * 0.5 or (vidx2 - vidx1) < mean_vertical_dist * 0.5:
+                continue
+            print(f"j_idx: {j_idx}, i_idx: {i_idx}")
+            cell = src[hidx1:hidx2, vidx1:vidx2]
+            # print(f"cell_shape: {cell.shape}, mean_horizontal_dist: {mean_horizontal_dist}, mean_vertical_dist: {mean_vertical_dist}")
+            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]
+            hists['top'][j_idx, i_idx] = np.sum(top)
+            left = cell[mid_x-5:mid_x+5, 0:10]
+            hists['left'][j_idx, i_idx] = np.sum(left)
+            right = cell[mid_x-5:mid_x+5, -10:]
+            hists['right'][j_idx, i_idx] = np.sum(right)
+            bottom = cell[-10:, mid_y-5:mid_y+5]
+            hists['bottom'][j_idx, i_idx] = np.sum(bottom)
+            i_idx += 1
+            i_len = max(i_len, i_idx)
+        if i_idx > 0:
+            j_idx += 1
+        j_len = max(j_len, j_idx)
+
+    fig, axs = plt.subplots(2, 2)
+    axs[0, 0].hist(list(hists['top'].values()), bins=100)
+    axs[0, 0].set_title('Top')
+    axs[0, 1].hist(list(hists['left'].values()), bins=100)
+    axs[0, 1].set_title('Left')
+    axs[1, 0].hist(list(hists['right'].values()), bins=100)
+    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')
+    axs[1, 1].axvline(target_bottom, color='red')
+    # plt.show()
+    # 1/0
+    arr = np.zeros((j_len, i_len), dtype=object)
+    output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
+    print(f"target_top: {target_top}, target_left: {target_left}, target_right: {target_right}, target_bottom: {target_bottom}, j_len: {j_len}, i_len: {i_len}")
+    for j in range(j_len):
+        for i in range(i_len):
+            if hists['top'][j, i] > target_top:
+                output['top'][j, i] = 1
+            if hists['left'][j, i] > target_left:
+                output['left'][j, i] = 1
+            if hists['right'][j, i] > target_right:
+                output['right'][j, i] = 1
+            if hists['bottom'][j, i] > target_bottom:
+                output['bottom'][j, i] = 1
+            print(f"cell_{j}_{i}", end=': ')
+            print('T' if output['top'][j, i] else '', end='')
+            print('L' if output['left'][j, i] else '', end='')
+            print('R' if output['right'][j, i] else '', end='')
+            print('B' if output['bottom'][j, i] else '', end='')
+            print('   Sums: ', hists['top'][j, i], hists['left'][j, i], hists['right'][j, i], hists['bottom'][j, i])
+
+    current_count = 0
+    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] == '  ':
+                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')
+        for i, row in enumerate(out):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(out) - 1:
+                f.write(',')
+            f.write('\n')
+        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
+    # main(Path(__file__).parent / 'input_output' / 'MTM6OSw4MjEsNDAx.png')
+    # 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' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MDoxNiwxNDQ=.png')
+    # main(Path(__file__).parent / 'input_output' / 'heyawake_MTQ6ODQ4LDEzOQ==.png')
+    # main(Path(__file__).parent / 'input_output' / 'sudoku_jigsaw.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 025846.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 035658.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-01 044110.png')
+    # main(Path(__file__).parent / 'input_output' / 'Screenshot 2025-11-03 020828.png')
+    main(Path(__file__).parent / 'input_output' / 'ripple_effect_unsolved.png')

puzzle_solver/puzzles/stitches/stitches.py

@@ -0,0 +1,96 @@
+from typing import Union
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_next_pos, Direction, get_row_pos, get_col_pos, in_bounds, get_opposite_direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+class Board:
+    def __init__(self, board: np.array, top: np.array, side: np.array, connection_count=1):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        assert top.ndim == 1 and top.shape[0] == self.H, 'top must be a 1d array of length board width'
+        assert side.ndim == 1 and side.shape[0] == self.V, 'side must be a 1d array of length board height'
+        assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
+        assert isinstance(connection_count, int) and connection_count >= 1, f'connection count must be int and >= 1, got {connection_count}'
+        self.board = board
+        self.top = top
+        self.side = side
+        self.connection_count = connection_count
+        self.top_empties = [self.H - i for i in self.top]
+        self.side_empties = [self.V - i for i in self.side]
+        self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
+        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}
+        # keys are (block_i, block_j) where block_i < block_j to avoid double counting
+        # values are sets of (pos_a, direction_a, pos_b, direction_b) where the two blocks meet
+        self.block_neighbors: dict[tuple[int, int], set[tuple[Pos, Direction, Pos, Direction]]] = {}
+        self.valid_stitches: set[tuple[Pos, Pos]] = set()  # records all pairs of positions that can have a stitch
+        for pos in get_all_pos(self.V, self.H):
+            block_i = int(get_char(self.board, pos))
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    continue
+                block_j = int(get_char(self.board, neighbor))
+                if block_i < block_j:  # avoid double counting
+                    opposite_direction = get_opposite_direction(direction)
+                    self.block_neighbors.setdefault((block_i, block_j), set()).add((pos, direction, neighbor, opposite_direction))
+                    self.valid_stitches.add((pos, neighbor))
+                    self.valid_stitches.add((neighbor, pos))
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, Union[Direction, None]], cp_model.IntVar] = {}
+        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:
+                self.model_vars[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
+            self.model_vars[(pos, None)] = self.model.NewBoolVar(f'{pos}:empty')
+
+    def add_all_constraints(self):
+        # every position has exactly 1 state
+        for pos in get_all_pos(self.V, self.H):
+            state = [self.model_vars[(pos, direction)] for direction in Direction]
+            state.append(self.model_vars[(pos, None)])
+            self.model.AddExactlyOne(state)
+        # If a position points at X (and this is a valid pair) then X has to point at me
+        for pos in get_all_pos(self.V, self.H):
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                if not in_bounds(neighbor, self.V, self.H) or (pos, neighbor) not in self.valid_stitches:  # this is not a valid stitch
+                    self.model.Add(self.model_vars[(pos, direction)] == 0)
+                    continue
+                opposite_direction = get_opposite_direction(direction)
+                self.model.Add(self.model_vars[(pos, direction)] == self.model_vars[(neighbor, opposite_direction)])
+
+        # all blocks connected exactly N times (N usually 1 but can be 2 or 3)
+        for connections in self.block_neighbors.values():
+            is_connected_list = []
+            for pos_a, direction_a, pos_b, direction_b in connections:
+                v = self.model.NewBoolVar(f'{pos_a}:{direction_a}->{pos_b}:{direction_b}')
+                and_constraint(self.model, v, [self.model_vars[pos_a, direction_a], self.model_vars[pos_b, direction_b]])
+                is_connected_list.append(v)
+            self.model.Add(sum(is_connected_list) == self.connection_count)
+
+        # sums of top and side must match
+        for col in range(self.H):
+            self.model.Add(sum([self.model_vars[pos, None] for pos in get_col_pos(col, self.V)]) == self.top_empties[col])
+        for row in range(self.V):
+            self.model.Add(sum([self.model_vars[pos, None] for pos in get_row_pos(row, self.H)]) == self.side_empties[row])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: direction.name[0] if direction is not None else ' ' for (pos, direction), var in board.model_vars.items() if solver.Value(var) == 1 and direction is not None})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
+                special_content=lambda r, c: single_res.assignment.get(get_pos(x=c, y=r), ''),
+                center_char=lambda r, c: 'O' if get_pos(x=c, y=r) in single_res.assignment else '.'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=9)