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

puzzle_solver/puzzles/shingoki/shingoki.py

@@ -0,0 +1,116 @@
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Direction, Pos, get_all_pos, get_next_pos, get_char, in_bounds, set_char, get_pos, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_unique_projections, force_connected_component_using_demand, and_constraint, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
+    out = []
+    while True:
+        out.append(pos)
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+    return out
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item().strip() == '') or (str(c.item())[:-1].isdecimal() and c.item()[-1].upper() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only space or digits and B/W'
+        self.V, self.H = board.shape
+        self.board = board
+        self.board_numbers: dict[Pos, int] = {}
+        self.board_colors: dict[Pos, str] = {}
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(board, pos)
+            if c.strip() == '':
+                continue
+            self.board_numbers[pos] = int(c[:-1])
+            self.board_colors[pos] = c[-1].upper()
+
+        self.model = cp_model.CpModel()
+        self.cell_active: dict[Pos, cp_model.IntVar] = {}
+        self.cell_direction: dict[tuple[Pos, Direction], 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.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
+            for direction in Direction:
+                neighbor = get_next_pos(pos, direction)
+                opposite_direction = get_opposite_direction(direction)
+                if not in_bounds(neighbor, self.V, self.H):
+                    self.cell_direction[(pos, direction)] = self.model.NewConstant(0)
+                    continue
+                if (neighbor, opposite_direction) in self.cell_direction:
+                    self.cell_direction[(pos, direction)] = self.cell_direction[(neighbor, opposite_direction)]
+                else:
+                    self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}-{neighbor}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            s = sum([self.cell_direction[(pos, direction)] for direction in Direction])
+            self.model.Add(s == 2).OnlyEnforceIf(self.cell_active[pos])
+            self.model.Add(s == 0).OnlyEnforceIf(self.cell_active[pos].Not())
+            if pos not in self.board_numbers:
+                continue
+            self.enforce_corner_color_and_number(pos, self.board_colors[pos], self.board_numbers[pos])  # enforce colors and number
+        self.force_connected_component()  # enforce single connected component
+
+    def enforce_corner_color_and_number(self, pos: Pos, pos_color: str, pos_number: int):
+        assert pos_color in ['W', 'B'] and pos_number > 0, f'Invalid color or number: {pos_color}, {pos_number}'
+        self.model.Add(self.cell_active[pos] == 1)
+        if pos_color == 'W':  # White circles must be passed through in a straight line
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == self.cell_direction[(pos, Direction.LEFT)])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == self.cell_direction[(pos, Direction.UP)])
+        elif pos_color == 'B':  # Black circles must be turned upon
+            self.model.Add(self.cell_direction[(pos, Direction.RIGHT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.LEFT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.LEFT)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.RIGHT)]])
+            self.model.Add(self.cell_direction[(pos, Direction.DOWN)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.UP)]])
+            self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0).OnlyEnforceIf([self.cell_direction[(pos, Direction.DOWN)]])
+        else:
+            raise ValueError(f'Invalid color: {pos_color}')
+        vis_vars: list[cp_model.IntVar] = []  # The numbers in the circles show the sum of the lengths of the 2 straight lines going out of that circle.
+        for direction in Direction:  # Build visibility chains in four direction
+            ray = get_ray(pos, self.V, self.H, direction)  # cells outward
+            for idx in range(len(ray)):
+                v = self.model.NewBoolVar(f"vis[{pos}]->({direction.name})[{idx}]")
+                and_constraint(self.model, target=v, cs=[self.cell_direction[(p, direction)] for p in ray[:idx+1]])
+                vis_vars.append(v)
+        self.model.Add(sum(vis_vars) == pos_number)
+
+    def force_connected_component(self):
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2 and d1 != d2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        force_connected_component_using_demand(self.model, self.cell_direction, 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] = defaultdict(str)
+            for (pos, direction), var in board.cell_direction.items():
+                assignment[pos] += direction.name[0] if solver.BooleanValue(var) else ''
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            output_board = np.full((self.V, self.H), '', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if get_char(self.board, pos)[-1] in ['B', 'W']:  # if the main board has a white or black pearl, put it in the output
+                    set_char(output_board, pos, get_char(self.board, pos))
+                if not single_res.assignment[pos].strip():  # if the cell does not the line through it, put a dot
+                    set_char(output_board, pos, '.')
+            print(combined_function(self.V, self.H, show_grid=False, special_content=lambda r, c: single_res.assignment[get_pos(x=c, y=r)], center_char=lambda r, c: output_board[r, c]))
+        project_vars = list(self.cell_direction.values())
+        return generic_unique_projections(self, project_vars, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/signpost/signpost.py

@@ -0,0 +1,93 @@
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.sat.python.cp_model import LinearExpr as lxp
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, in_bounds, get_next_pos, Direction8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+CHAR_TO_DIRECTION8 = {
+    'Q': Direction8.UP_LEFT,
+    'W': Direction8.UP,
+    'E': Direction8.UP_RIGHT,
+    'A': Direction8.LEFT,
+    'D': Direction8.RIGHT,
+    'Z': Direction8.DOWN_LEFT,
+    'X': Direction8.DOWN,
+    'C': Direction8.DOWN_RIGHT,
+}
+
+
+def beam(pos: Pos, V: int, H: int, direction: Direction8) -> list[Pos]:
+    out = []
+    while True:
+        pos = get_next_pos(pos, direction)
+        if not in_bounds(pos, V, H):
+            break
+        out.append(pos)
+    return out
+
+class Board:
+    def __init__(self, board: np.array, values: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert values.ndim == 2, f'values must be 2d, got {values.ndim}'
+        assert board.shape == values.shape, f'board and values must have the same shape, got {board.shape} and {values.shape}'
+        self.board = board
+        self.values = values
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.N = self.V * self.H
+        assert all(int(c.item()) >= 0 and int(c.item()) <= self.N for c in np.nditer(values)), 'values must contain only integers between 0 and N'
+
+        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(V=self.V, H=self.H):
+            self.model_vars[pos] = self.model.NewIntVar(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        # constrain clues
+        for pos in get_all_pos(V=self.V, H=self.H):
+            c = int(get_char(self.values, pos))
+            if c == 0:
+                continue
+            self.model.Add(self.model_vars[pos] == c)
+        # all values are unique
+        self.model.AddAllDifferent(list(self.model_vars.values()))
+        # arrow for x points to x+1
+        for pos in get_all_pos(V=self.V, H=self.H):
+            c = get_char(self.board, pos)
+            if c == ' ':
+                continue
+            direction = CHAR_TO_DIRECTION8[c]
+            self.constrain_plus_one(pos, direction)
+
+    def constrain_plus_one(self, pos: Pos, direction: Direction8):
+        beam_res = beam(pos, self.V, self.H, direction)
+        is_eq_list = []
+        for p in beam_res:
+            aux = self.model.NewBoolVar(f'{pos}:{p}')
+            self.model.Add(self.model_vars[p] == self.model_vars[pos] + 1).OnlyEnforceIf(aux)
+            self.model.Add(self.model_vars[p] != self.model_vars[pos] + 1).OnlyEnforceIf(aux.Not())
+            is_eq_list.append(aux)
+        self.model.Add(lxp.Sum(is_eq_list) == 1)
+
+    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, 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(V=self.V, H=self.H):
+                c = get_char(self.board, pos)
+                c = single_res.assignment[pos]
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=20)

puzzle_solver/puzzles/singles/singles.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+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}'
+        self.board = board
+        self.V, self.H = board.shape
+        self.N = self.V * self.H
+        self.idx_of: dict[Pos, int] = get_all_pos_to_idx_dict(self.V, self.H)
+
+        self.model = cp_model.CpModel()
+        self.B: dict[Pos, cp_model.IntVar] = {}
+        self.W: dict[Pos, cp_model.IntVar] = {}
+        self.Num: dict[Pos, cp_model.IntVar] = {} # value of squares (Num = N + idx if black, else board[pos])
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.W[pos] = self.B[pos].Not()
+            self.Num[pos] = self.model.NewIntVar(0, 2*self.N, f'{pos}')
+            self.model.Add(self.Num[pos] == self.N + self.idx_of[pos]).OnlyEnforceIf(self.B[pos])
+            self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.W[pos])
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # no two black squares are adjacent
+            for neighbor in get_neighbors4(pos, self.V, self.H):
+                self.model.Add(self.B[pos] + self.B[neighbor] <= 1)
+        for row in range(self.V):  # no number appears twice in any row (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_row_pos(row, self.H)])
+        for col in range(self.H):  # no number appears twice in any column (numbers are ignored if black)
+            self.model.AddAllDifferent([self.Num[pos] for pos in get_col_pos(col, self.V)])
+        force_connected_component(self.model, self.W)  # all white squares must be a single connected component
+
+    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(var) for pos, var in board.B.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H,
+                is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)],
+                center_char=lambda r, c: self.board[r, c],
+                text_on_shaded_cells=False
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slant/parse_map/parse_map.py

@@ -0,0 +1,135 @@
+"""
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html 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 itertools
+from pathlib import Path
+import numpy as np
+cv = None
+
+
+def extract_lines(bw):
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = max(5, cols // 20)
+    h_kernel = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, h_kernel)
+    horizontal = cv.dilate(horizontal, h_kernel)
+    h_means = np.mean(horizontal, axis=1)
+    h_idx = np.where(h_means > np.percentile(h_means, 70))[0]
+
+    rows = vertical.shape[0]
+    verticalsize = max(5, rows // 20)
+    v_kernel = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, v_kernel)
+    vertical = cv.dilate(vertical, v_kernel)
+    v_means = np.mean(vertical, axis=0)
+    v_idx = np.where(v_means > np.percentile(v_means, 70))[0]
+    return h_idx, v_idx
+
+def mean_consecutives(arr):
+    if len(arr) == 0:
+        return arr
+    sums, counts = [arr[0]], [1]
+    for k in arr[1:]:
+        if k == sums[-1] + counts[-1]:
+            sums[-1] += k
+            counts[-1] += 1
+        else:
+            sums.append(k)
+            counts.append(1)
+    return np.array(sums)//np.array(counts)
+
+def main(img_path):
+    global cv
+    import cv2 as cv_module
+    cv = cv_module
+    image_path = Path(img_path)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(img_path, cv.IMREAD_COLOR)
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    inv = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(inv, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 15, -2)
+    h_idx, v_idx = extract_lines(bw)
+    h_idx = mean_consecutives(h_idx)
+    v_idx = mean_consecutives(v_idx)
+
+    # Estimate grid cell and circle radii
+    cell = int(np.median(np.diff(h_idx))) if len(h_idx) > 3 else 40
+    r_min = max(6, int(cell*0.18))
+    r_max = int(cell*0.52)
+
+    # Global Hough detection with parameter sweep
+    blur = cv.medianBlur(gray, 5)
+    detected = []  # x, y, r
+
+    for dp, p2 in itertools.product([1.2, 1.0], [20, 18, 16, 14, 12]):
+        circles = cv.HoughCircles(
+            blur, cv.HOUGH_GRADIENT, dp=dp, minDist=max(12, int(cell*0.75)),
+            param1=120, param2=p2, minRadius=r_min, maxRadius=r_max
+        )
+        if circles is not None:
+            for (x, y, r) in np.round(circles[0, :]).astype(int):
+                detected.append((x, y, r))
+
+    # Non-maximum suppression to remove duplicates
+    def nms(circles, dist_thr=10):
+        kept = []
+        for x,y,r in sorted(circles, key=lambda c: -c[2]):
+            if all((x-kx)**2+(y-ky)**2 > dist_thr**2 for kx,ky,kr in kept):
+                kept.append((x,y,r))
+        return kept
+
+    detected = nms(detected, dist_thr=max(10,int(cell*0.4)))
+
+    # Map circle centers to nearest intersection
+    H, W = len(h_idx), len(v_idx)
+    presence = np.zeros((H, W), dtype=int)
+
+    # Build KD-like search by grid proximity
+    tol = int(cell*0.5)  # max distance from an intersection to accept a circle
+    for (cx, cy, _) in detected:
+        # find nearest indices
+        j = int(np.argmin(np.abs(h_idx - cy)))
+        i = int(np.argmin(np.abs(v_idx - cx)))
+        if abs(h_idx[j]-cy) <= tol and abs(v_idx[i]-cx) <= tol:
+            presence[j, i] = 1
+
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(presence):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(presence) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+    print('output json: ', output_path)
+    print('output json: ', output_path)
+
+    overlay = src.copy()
+    for (cx, cy, r) in detected:
+        cv.circle(overlay, (cx, cy), r, (255,0,0), 2)
+    for j, y in enumerate(h_idx):
+        for i, x in enumerate(v_idx):
+            color = (0,0,255) if presence[j,i]==1 else (0,255,0)
+            cv.circle(overlay, (int(x), int(y)), 4, color, 2)
+    show_wait_destroy("overlay", overlay)
+
+
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+if __name__ == '__main__':
+    # to run this script and visualize the output, in the root run:
+    #  python .\src\puzzle_solver\puzzles\slant\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    main(Path(__file__).parent / 'input_output' / '23131379850022376.png')

puzzle_solver/puzzles/slant/slant.py

@@ -0,0 +1,111 @@
+from typing import Literal, Optional, Union
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, in_bounds, get_pos
+from puzzle_solver.core.utils_ortools import force_no_loops, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+@dataclass(frozen=True)
+class Node:
+    """The grid is represented as a graph of cells connected to corners."""
+    node_type: Union[Literal["Cell"], Literal["Corner"]]
+    pos: Pos
+    slant: Union[Literal["/"], Literal["\\"], None]
+
+    def get_neighbors(self, board_nodes: dict[tuple[str, Pos, Optional[str]], "Node"]) -> list["Node"]:
+        if self.node_type == "Cell" and self.slant == "/":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Cell" and self.slant == "\\":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Corner":
+            # 4 cells, 2 cells per slant
+            n1 = ("Cell", get_pos(self.pos.x-1, self.pos.y-1), "\\")
+            n2 = ("Cell", get_pos(self.pos.x, self.pos.y-1), "/")
+            n3 = ("Cell", get_pos(self.pos.x-1, self.pos.y), "/")
+            n4 = ("Cell", get_pos(self.pos.x, self.pos.y), "\\")
+            return {board_nodes[n] for n in [n1, n2, n3, n4] if n in board_nodes}
+
+
+class Board:
+    def __init__(self, numbers: Union[list[tuple[Pos, int]], np.array], V: int = None, H: int = None):
+        if isinstance(numbers, np.ndarray):
+            V, H = numbers.shape
+            V = V - 1
+            H = H - 1
+            numbers = [(get_pos(x=pos[1], y=pos[0]), int(d)) for pos, d in np.ndenumerate(numbers) if str(d).isdecimal()]
+            numbers = [(p, n) for p, n in numbers if n >= 0]
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if numbers is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(number, int) and number >= 0 for (pos, number) in numbers), 'numbers must be a list of integers'
+        self.V = V
+        self.H = H
+        self.numbers = numbers
+        self.pos_to_number: dict[Pos, int] = {pos: number for pos, number in numbers}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.nodes: dict[Node, cp_model.IntVar] = {}
+        self.neighbor_dict: dict[Node, set[Node]] = {}
+
+        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}:/')
+            self.model_vars[(pos, '\\')] = self.model.NewBoolVar(f'{pos}:\\')
+            self.model.AddExactlyOne([self.model_vars[(pos, '/')], self.model_vars[(pos, '\\')]])
+        for (pos, slant), v in self.model_vars.items():
+            self.nodes[Node(node_type="Cell", pos=pos, slant=slant)] = v
+        for pos in get_all_pos(self.V + 1, self.H + 1):
+            self.nodes[Node(node_type="Corner", pos=pos, slant=None)] = self.model.NewConstant(1)
+
+
+    def add_all_constraints(self):
+        for pos, number in self.pos_to_number.items():
+            # pos is a position on the intersection of 4 cells
+            # when pos is (xi, yi) then it gets a +1 contribution for each:
+            # - cell (xi-1, yi-1) is a "\\"
+            # - cell (xi, yi) is a "\\"
+            # - cell (xi, yi-1) is a "/"
+            # - cell (xi-1, yi) is a "/"
+            xi, yi = pos.x, pos.y
+            tl_pos = get_pos(xi-1, yi-1)
+            br_pos = get_pos(xi, yi)
+            tr_pos = get_pos(xi, yi-1)
+            bl_pos = get_pos(xi-1, yi)
+            tl_var = self.model_vars[(tl_pos, '\\')] if in_bounds(tl_pos, self.V, self.H) else 0
+            br_var = self.model_vars[(br_pos, '\\')] if in_bounds(br_pos, self.V, self.H) else 0
+            tr_var = self.model_vars[(tr_pos, '/')] if in_bounds(tr_pos, self.V, self.H) else 0
+            bl_var = self.model_vars[(bl_pos, '/')] if in_bounds(bl_pos, self.V, self.H) else 0
+            self.model.Add(sum([tl_var, tr_var, bl_var, br_var]) == number)
+        board_nodes = {(node.node_type, node.pos, node.slant): node for node in self.nodes.keys()}
+        self.neighbor_dict = {node: node.get_neighbors(board_nodes) for node in self.nodes.keys()}
+        no_loops_vars = force_no_loops(self.model, self.nodes, is_neighbor=lambda n1, n2: n1 in self.neighbor_dict[n2])
+        self.no_loops_vars = no_loops_vars
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            # graph = {node: solver.Value(var) for node, var in board.nodes.items()}
+            for (pos, s), var in board.model_vars.items():
+                if solver.Value(var) == 1:
+                    assignment[pos] = s
+            for p in get_all_pos(self.V, self.H):
+                assert p in assignment, f'position {p} is not assigned a number'
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: single_res.assignment[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/slitherlink/slitherlink.py

@@ -0,0 +1,130 @@
+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, 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
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+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
+
+        # 2N^2 + 2N edges
+        # 4*edges (fully connected component)
+        # model variables = edges (on/off) + 4*edges (fully connected component)
+        # = 9N^2 + 9N
+        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 won't 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))
+
+        corner_sum_domain = cp_model.Domain.FromValues([0, 2])  # sum of edges touching a corner is 0 or 2
+        for corner in self.corner_vars:  # a corder always has 0 or 2 active edges
+            self.model.AddLinearExpressionInDomain(sum(self.corner_vars[corner]), corner_sum_domain)
+
+        # 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)
+            # replace " " with "·"
+            board = np.where(self.board == ' ', '·', self.board)
+            print(combined_function(self.V, self.H, cell_flags=lambda r, c: res[r, c], center_char=lambda r, c: board[r, c]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=999)