multi-puzzle-solver 0.9.15__py3-none-any.whl → 0.9.20__py3-none-any.whl

{multi_puzzle_solver-0.9.15.dist-info → multi_puzzle_solver-0.9.20.dist-info}/RECORD

@@ -1,6 +1,6 @@
-puzzle_solver/__init__.py,sha256=hsdC4t9rGAyQMPNuCjepmf4hZhoUgGbAW83ROdkDAoc,2574
+puzzle_solver/__init__.py,sha256=EuBuJfRIA3IGQExkQ5h4BNYXWHLzdZh3j65ocCMy_64,2855
 puzzle_solver/core/utils.py,sha256=_LA81kHrsgvqPvq7RISBeaurXmYMKAU9N6qmV8n0G7s,8063
-puzzle_solver/core/utils_ortools.py,sha256=SZQyLE6eld7B_Zq5AjyVjeGimsxoRk3D7M40wWWExIE,10463
+puzzle_solver/core/utils_ortools.py,sha256=2xEL9cMEKmNhRD9lhr2nGdZ3Lbmc9cnHY8xv6iLhUr0,10542
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
 puzzle_solver/puzzles/battleships/battleships.py,sha256=RuYCrs4j0vUjlU139NRYYP-uNPAgO0V7hAzbsHrRwD8,7446
 puzzle_solver/puzzles/black_box/black_box.py,sha256=ZnHDVt6PFS_r1kMNSsbz9hav1hxIrNDUvPyERGPjLjM,15635
@@ -11,8 +11,8 @@ puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=U3v766UsZHx_dC3gxqU90VbjA
 puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
 puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
 puzzle_solver/puzzles/filling/filling.py,sha256=vrOIil285_r3IQ0F4c9mUBWMRVlPH4vowog_z1tCGdI,5567
-puzzle_solver/puzzles/galaxies/galaxies.py,sha256=AJwH-HMpSvOAu2DTV-VbP52jUK0hmlkP31g4xB0F3K4,5607
-puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=DzVEihO6gokBDo-joSKCSyfdSsRdpZy3Ft50--nJyak,9354
+puzzle_solver/puzzles/galaxies/galaxies.py,sha256=p10lpmW0FjtneFCMEjG1FSiEpQuvD8zZG9FG8zYGoes,5582
+puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=v5TCrdREeOB69s9_QFgPHKA7flG69Im1HVzIdxH0qQc,9355
 puzzle_solver/puzzles/guess/guess.py,sha256=sH-NlYhxM3DNbhk4eGde09kgM0KaDvSbLrpHQiwcFGo,10791
 puzzle_solver/puzzles/inertia/inertia.py,sha256=gJBahkh69CrSWNscalKEoP1j4X-Q3XpbIBMiG9PUpU0,5657
 puzzle_solver/puzzles/inertia/tsp.py,sha256=gobiISHtARA4Elq0jr90p6Yhq11ULjGoqsS-rLFhYcc,15389
@@ -26,24 +26,28 @@ puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=1jmDTOCnmivmBlwtMDyyk3TVqH5IjapzLn7zLQ4qubk,6056
-puzzle_solver/puzzles/norinori/norinori.py,sha256=Z2c0iEn7a6S6gaaJlvNMNNbAQwpztNLB0LTH_XVgu74,12269
+puzzle_solver/puzzles/norinori/norinori.py,sha256=uC8vXAw35xsTmpmTeKqYW7tbcssms9LCcXFBONtV2Ng,4743
 puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
 puzzle_solver/puzzles/range/range.py,sha256=rruvD5ZSaOgvQuX6uGV_Dkr82nSiWZ5kDz03_j7Tt24,4425
 puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOHiTM6t08dLLDac,3869
 puzzle_solver/puzzles/singles/singles.py,sha256=3wACiUa1Vmh2ce6szQ2hPjyBuH7aHiQ888p4R2jFkW4,3342
+puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
+puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=dxnALSDXe9wU0uSD0QEXnzoh1q801mj1ePTNLtG0n60,4796
+puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=jw-Buwzo_eZADL45zD5-Hs8HaT3AU4dZn6eifCUPnhA,11701
 puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
-puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=VWHT-iYDaFsd37h9DE07EkeZ_dJMEfatXSByqC2vh04,8916
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=1LNJkIqpcz1LvY0H0uRedABQWm44dgNf9XeQuKm36WM,10275
 puzzle_solver/puzzles/sudoku/sudoku.py,sha256=M_pry7XyKKzlfCF5rFi02lyOrj5GWZzXnDAxmD3NXvI,3588
 puzzle_solver/puzzles/tents/tents.py,sha256=iyVK2WXfIT5j_9qqlQg0WmwvixwXlZSsHGK3XA-KpII,6283
 puzzle_solver/puzzles/thermometers/thermometers.py,sha256=nsvJZkm7G8FALT27bpaB0lv5E_AWawqmvapQI8QcYXw,4015
 puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFBSudve68wk,6496
 puzzle_solver/puzzles/tracks/tracks.py,sha256=98xds9SKNqtOLFTRUX_KSMC7XYmZo567LOFeqotVQaM,7237
 puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
+puzzle_solver/puzzles/unequal/unequal.py,sha256=ExY2XDCrqROCDpRLfHo8uVr1zuli1QvbCdNCiDhlCac,6978
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.15.dist-info/METADATA,sha256=LIonrn93fVCBRPPgFoBKnSezECoANY9lY5JXIKss_g8,148507
-multi_puzzle_solver-0.9.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.15.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.15.dist-info/RECORD,,
+multi_puzzle_solver-0.9.20.dist-info/METADATA,sha256=R36gUfx8jHLCnOMt4QEYf-wtBYskwk46IxxPJGMapjI,180363
+multi_puzzle_solver-0.9.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.20.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.20.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -18,11 +18,14 @@ from puzzle_solver.puzzles.map import map as map_solver
 from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
 from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
 from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
+from puzzle_solver.puzzles.norinori import norinori as norinori_solver
 from puzzle_solver.puzzles.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
 from puzzle_solver.puzzles.signpost import signpost as signpost_solver
 from puzzle_solver.puzzles.singles import singles as singles_solver
+from puzzle_solver.puzzles.slant import slant as slant_solver
+from puzzle_solver.puzzles.slitherlink import slitherlink as slitherlink_solver
 from puzzle_solver.puzzles.star_battle import star_battle as star_battle_solver
 from puzzle_solver.puzzles.star_battle import star_battle_shapeless as star_battle_shapeless_solver
 from puzzle_solver.puzzles.stitches import stitches as stitches_solver
@@ -32,8 +35,9 @@ from puzzle_solver.puzzles.thermometers import thermometers as thermometers_solv
 from puzzle_solver.puzzles.towers import towers as towers_solver
 from puzzle_solver.puzzles.tracks import tracks as tracks_solver
 from puzzle_solver.puzzles.undead import undead as undead_solver
+from puzzle_solver.puzzles.unequal import unequal as unequal_solver
 from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.15'
+__version__ = '0.9.20'

puzzle_solver/core/utils_ortools.py

@@ -175,10 +175,15 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
     tree_edge: dict[tuple[Pos, Pos], cp_model.IntVar] = {}  # tree_edge[p, q] means p is parent of q
     prefix_name = "no_loops_"
 
-    def parent_of(p: Pos) -> list[Pos]:
-        return [q for q in keys_in_order if (q, p) in tree_edge]
-    def children_of(p: Pos) -> list[Pos]:
-        return [q for q in keys_in_order if (p, q) in tree_edge]
+    parent_of = {p: [] for p in vs.keys()}
+    children_of = {p: [] for p in vs.keys()}
+    for p in vs.keys():
+        for q in vs.keys():
+            if p == q:
+                continue
+            if is_neighbor(p, q):
+                parent_of[q].append(p)
+                children_of[p].append(q)
 
     keys_in_order = list(vs.keys())  # must enforce some ordering
     node_to_idx: dict[Pos, int] = {p: i+1 for i, p in enumerate(keys_in_order)}
@@ -197,16 +202,13 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
         model.Add(block_root[p] == node_to_idx[p]).OnlyEnforceIf([is_root[p]])
 
     for p in keys_in_order:
-        for q in keys_in_order:
-            if p == q:
-                continue
-            if is_neighbor(p, q):
-                tree_edge[(p, q)] = model.NewBoolVar(f"{prefix_name}tree_edge[{p} is parent of {q}]")
-                model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[p].Not()])
-                model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[q].Not()])
-                # a tree_edge[p, q] means p is parent of q thus h[q] = h[p] + 1
-                model.Add(node_height[q] == node_height[p] + 1).OnlyEnforceIf([tree_edge[(p, q)]])
-                model.Add(block_root[q] == block_root[p]).OnlyEnforceIf([tree_edge[(p, q)]])
+        for q in children_of[p]:
+            tree_edge[(p, q)] = model.NewBoolVar(f"{prefix_name}tree_edge[{p} is parent of {q}]")
+            model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[p].Not()])
+            model.Add(tree_edge[(p, q)] == 0).OnlyEnforceIf([vs[q].Not()])
+            # a tree_edge[p, q] means p is parent of q thus h[q] = h[p] + 1
+            model.Add(node_height[q] == node_height[p] + 1).OnlyEnforceIf([tree_edge[(p, q)]])
+            model.Add(block_root[q] == block_root[p]).OnlyEnforceIf([tree_edge[(p, q)]])
 
     for (p, q) in tree_edge:
         if (q, p) in tree_edge:
@@ -214,14 +216,14 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
             model.Add(tree_edge[(p, q)] == 1).OnlyEnforceIf([tree_edge[(q, p)].Not(), vs[p], vs[q]])
 
     for p in keys_in_order:
-        for p_child in children_of(p):
+        for p_child in children_of[p]:
             # i am root thus I point to all my children
             model.Add(tree_edge[(p, p_child)] == 1).OnlyEnforceIf([is_root[p], vs[p_child]])
-        for p_parent in parent_of(p):
+        for p_parent in parent_of[p]:
             # i am root thus I have no parent
             model.Add(tree_edge[(p_parent, p)] == 0).OnlyEnforceIf([is_root[p]])
         # every active node has exactly 1 parent except root has none
-        model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of(p)] + [vs[p].Not(), is_root[p]])
+        model.AddExactlyOne([tree_edge[(p_parent, p)] for p_parent in parent_of[p]] + [vs[p].Not(), is_root[p]])
     
     # now each subgraph has directions where each non-root points to a single parent (and its value is parent+1). 
     # to break cycles, every non-root active node must be > all neighbors that arent children
@@ -233,5 +235,7 @@ def force_no_loops(model: cp_model.CpModel, vars_to_force: dict[Any, cp_model.In
         all_new_vars[f"{prefix_name}tree_edge[{k[0]} is parent of {k[1]}]"] = v
     for k, v in node_height.items():
         all_new_vars[f"{prefix_name}node_height[{k}]"] = v
+    for k, v in block_root.items():
+        all_new_vars[f"{prefix_name}block_root[{k}]"] = v
 
     return all_new_vars

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -4,8 +4,8 @@ from typing import Iterable, Union
 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, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint, force_connected_component
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
 
 
 def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:

puzzle_solver/puzzles/galaxies/parse_map/parse_map.py

@@ -1,5 +1,5 @@
 """
-    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. 
+    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.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.
 """

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/slant/parse_map/parse_map.py

@@ -0,0 +1,133 @@
+"""
+    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 json, 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, r) 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')