multi-puzzle-solver 0.9.12__py3-none-any.whl → 0.9.13__py3-none-any.whl

{multi_puzzle_solver-0.9.12.dist-info → multi_puzzle_solver-0.9.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.12
+Version: 0.9.13
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver
@@ -260,8 +260,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
     </a>
   </td>
   <td align="center">
-    <a href="#norinori-puzzle-type-33"><b>Norinori</b><br><br>
-      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_solved.png" alt="Norinori" width="140">
+    <a href="#lits-puzzle-type-33"><b>Lits</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_solved.png" alt="Lits" width="140">
     </a>
   </td>
 </tr>
@@ -311,7 +311,7 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Kakurasu (Puzzle Type #30)](#kakurasu-puzzle-type-30)
   - [Star Battle (Puzzle Type #31)](#star-battle-puzzle-type-31)
   - [Star Battle Shapeless (Puzzle Type #32)](#star-battle-shapeless-puzzle-type-32)
-  - [Norinori (Puzzle Type #33)](#norinori-puzzle-type-33)
+  - [Lits (Puzzle Type #33)](#lits-puzzle-type-33)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -2693,9 +2693,9 @@ Time taken: 0.02 seconds
 
 ---
 
-## Norinori (Puzzle Type #33)
+## Lits (Puzzle Type #33)
 
-* [**Play online**](https://www.puzzle-norinori.com/)
+* [**Play online**](https://www.puzzle-lits.com/)
 
 * [**Solver Code**][33]
 
@@ -2715,7 +2715,7 @@ Note: The solver is capable of solving variations where the puzzle pieces the ma
 
 **Unsolved puzzle**
 
-<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_unsolved.png" alt="Norinori unsolved" width="500">
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_unsolved.png" alt="Lits unsolved" width="500">
 
 Code to utilize this package and solve the puzzle:
 
@@ -2778,7 +2778,7 @@ Time taken: 0.38 seconds
 
 **Solved puzzle**
 
-<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/norinori_solved.png" alt="Norinori solved" width="500">
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/lits_solved.png" alt="Lits solved" width="500">
 
 ---
 
@@ -2865,4 +2865,4 @@ Issues and PRs welcome!
 [30]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/kakurasu "puzzle_solver/src/puzzle_solver/puzzles/kakurasu at master · Ar-Kareem/puzzle_solver · GitHub"
 [31]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle "puzzle_solver/src/puzzle_solver/puzzles/star_battle at master · Ar-Kareem/puzzle_solver · GitHub"
 [32]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/star_battle_shapeless "puzzle_solver/src/puzzle_solver/puzzles/star_battle_shapeless at master · Ar-Kareem/puzzle_solver · GitHub"
-[33]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/norinori "puzzle_solver/src/puzzle_solver/puzzles/norinori at master · Ar-Kareem/puzzle_solver · GitHub"
+[33]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/lits "puzzle_solver/src/puzzle_solver/puzzles/lits at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.12.dist-info → multi_puzzle_solver-0.9.13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-puzzle_solver/__init__.py,sha256=TiVEPMsHf9jGYdNPz052mX7Q9XjTh7V6Lf8CpFhW1o8,2441
+puzzle_solver/__init__.py,sha256=3aQDyvMPWTlYKDo3j-v4x_lUcNbp7KyallMChQEeJY0,2429
 puzzle_solver/core/utils.py,sha256=D7enPxJjnsTbGDqqtOtGaRaetwGs0nqrNtTnrqhMB-g,3408
 puzzle_solver/core/utils_ortools.py,sha256=eoT9hSJe-c67A_hsu1jnMpyRgMrTtUs5n2j_m5Hk8Do,7362
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
@@ -17,6 +17,7 @@ puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQ
 puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
 puzzle_solver/puzzles/keen/keen.py,sha256=tDb6C5S3Q0JAKPsdw-84WQ6PxRADELZHr_BK8FDH-NA,5039
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
+puzzle_solver/puzzles/lits/lits.py,sha256=gYAcsuWucSer2JWs5eKOroiVmjfi-VzccmZvBIUIFks,12014
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
 puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
@@ -30,7 +31,7 @@ puzzle_solver/puzzles/singles/singles.py,sha256=kwMENfqQ-OP3YIz5baY6LRcvYCsNfhIm
 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=S0cV5WOQLFUOQ0OYzaoGdol6GirCulFEOOIvnIpoO6A,9128
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=VWHT-iYDaFsd37h9DE07EkeZ_dJMEfatXSByqC2vh04,8916
 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
@@ -39,7 +40,7 @@ puzzle_solver/puzzles/tracks/tracks.py,sha256=0K1YZMHiRIMmFwoD_JxB2c_xB6GYV8spgN
 puzzle_solver/puzzles/undead/undead.py,sha256=IrCUfzQFBem658P5KKqldG7vd2TugTHehcwseCarerM,6604
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.12.dist-info/METADATA,sha256=YvLLSim71OsFEGhz23K2CAkszd78vxjx1dO1MsUdD7U,143237
-multi_puzzle_solver-0.9.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.12.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.12.dist-info/RECORD,,
+multi_puzzle_solver-0.9.13.dist-info/METADATA,sha256=x82w11xGJo2Rb4cGGQkmlbQNZ1i7MPGuhxCjOyaj61Y,143181
+multi_puzzle_solver-0.9.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.13.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.13.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -16,7 +16,7 @@ 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
@@ -34,4 +34,4 @@ 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.12'
+__version__ = '0.9.13'

puzzle_solver/puzzles/lits/lits.py

@@ -0,0 +1,255 @@
+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 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)
+
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+    disallow_same_shape: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array, polyomino_degrees: int = 4):
+        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.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.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.create_vars()
+        self.init_shapes_on_board()
+        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}')
+        # 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))
+
+    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:
+            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)
+        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 ' '
+                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

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -1,212 +1,212 @@
-"""
-    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.
-"""
-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 // 5
-    # 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 // 5
-    # 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 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}'
-    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)
-    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}")
-    arr = np.zeros((height - 1, width - 1), dtype=object)
-    output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
-    target = 200_000
-    hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
-    for j in range(height - 1):
-        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)
-            cell = src[hidx1:hidx2, vidx1:vidx2]
-            mid_x = cell.shape[1] // 2
-            mid_y = cell.shape[0] // 2
-            # 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, i] = np.sum(top)
-            left = cell[mid_x-5:mid_x+5, 0:10]
-            hists['left'][j, i] = np.sum(left)
-            right = cell[mid_x-5:mid_x+5, -10:]
-            hists['right'][j, i] = np.sum(right)
-            bottom = cell[-10:, mid_y-5:mid_y+5]
-            hists['bottom'][j, i] = np.sum(bottom)
-
-    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')
-    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()))
-    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
-    print(f"target_top: {target_top}, target_left: {target_left}, target_right: {target_right}, target_bottom: {target_bottom}")
-    for j in range(height - 1):
-        for i in range(width - 1):
-            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
-    out = np.full_like(output['top'], '  ', dtype='U2')
-    for j in range(out.shape[0]):
-        for i in range(out.shape[1]):
-            if out[j, i] == '  ':
-                dfs(i, j, out, output, str(current_count).zfill(2))
-                current_count += 1
-
-    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)
-
-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')
+"""
+    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.
+"""
+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 // 5
+    # 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 // 5
+    # 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 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}'
+    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)
+    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}")
+    arr = np.zeros((height - 1, width - 1), dtype=object)
+    output = {'top': arr.copy(), 'left': arr.copy(), 'right': arr.copy(), 'bottom': arr.copy()}
+    target = 200_000
+    hists = {'top': {}, 'left': {}, 'right': {}, 'bottom': {}}
+    for j in range(height - 1):
+        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)
+            cell = src[hidx1:hidx2, vidx1:vidx2]
+            mid_x = cell.shape[1] // 2
+            mid_y = cell.shape[0] // 2
+            # 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, i] = np.sum(top)
+            left = cell[mid_x-5:mid_x+5, 0:10]
+            hists['left'][j, i] = np.sum(left)
+            right = cell[mid_x-5:mid_x+5, -10:]
+            hists['right'][j, i] = np.sum(right)
+            bottom = cell[-10:, mid_y-5:mid_y+5]
+            hists['bottom'][j, i] = np.sum(bottom)
+
+    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')
+    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()))
+    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
+    print(f"target_top: {target_top}, target_left: {target_left}, target_right: {target_right}, target_bottom: {target_bottom}")
+    for j in range(height - 1):
+        for i in range(width - 1):
+            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
+    out = np.full_like(output['top'], '  ', dtype='U2')
+    for j in range(out.shape[0]):
+        for i in range(out.shape[1]):
+            if out[j, i] == '  ':
+                dfs(i, j, out, output, str(current_count).zfill(2))
+                current_count += 1
+
+    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)
+
+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')