multi-puzzle-solver 0.9.3__py3-none-any.whl → 0.9.4__py3-none-any.whl

{multi_puzzle_solver-0.9.3.dist-info → multi_puzzle_solver-0.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.3
+Version: 0.9.4
 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
@@ -232,6 +232,11 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
       <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/aquarium_solved.png" alt="Aquarium" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#stitches-puzzle-type-28"><b>Stitches</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/stitches_solved.png" alt="Stitches" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -274,6 +279,7 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Chess Melee (Puzzle Type #25)](#chess-melee-puzzle-type-25)
   - [Thermometers (Puzzle Type #26)](#thermometers-puzzle-type-26)
   - [Aquarium (Puzzle Type #27)](#aquarium-puzzle-type-27)
+  - [Stitches (Puzzle Type #28)](#stitches-puzzle-type-28)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -2134,8 +2140,6 @@ The numbers outside the grid show the number of filled cells horizontally and ve
 
 Code to utilize this package and solve the puzzle:
 
-(Note that this puzzle does not typically have a unique solution. Thus, we specify here that we only want the first valid solution that the solver finds.)
-
 ```python
 from puzzle_solver import thermometers_solver as solver
 board = np.array([
@@ -2184,6 +2188,12 @@ status: OPTIMAL
 Time taken: 0.01 seconds
 ```
 
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/thermometers_solved.png" alt="Thermometers solved" width="500">
+
+---
+
 ## Aquarium (Puzzle Type #27)
 
 * [**Play online**](https://www.puzzle-aquarium.com/)
@@ -2209,8 +2219,6 @@ The numbers outside the grid show the number of filled cells horizontally and ve
 
 Code to utilize this package and solve the puzzle:
 
-(Note that this puzzle does not typically have a unique solution. Thus, we specify here that we only want the first valid solution that the solver finds.)
-
 ```python
 from puzzle_solver import aquarium_solver as solver
 board = np.array([
@@ -2265,6 +2273,83 @@ Time taken: 0.02 seconds
 
 ---
 
+## Stitches (Puzzle Type #28)
+
+* [**Play online**](https://www.puzzle-stitches.com/)
+
+* [**Solver Code**][28]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+- Connect each block with ALL its neighbor blocks with exactly 1 "stitch" each.
+- A "stitch" connects 2 orthogonally adjacent cells from different blocks.
+- 2 stitches cannot share a hole.
+- The clues outside the grid indicate the number of holes on that row/column
+- For 2÷ puzzles, you have to use 2 stitches to connect neighbor blocks, for 3÷ puzzles - 3 stitches etc.
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/stitches_unsolved.png" alt="Stitches unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+```python
+from puzzle_solver import stitches_solver as solver
+board = np.array([
+  ["00", "00", "00", "00", "00", "01", "01", "01", "01", "01", "01", "01", "01", "02", "02"],
+  ["00", "03", "03", "04", "00", "00", "01", "05", "05", "05", "05", "05", "01", "01", "02"],
+  ["00", "03", "04", "04", "04", "00", "05", "05", "05", "05", "05", "05", "05", "05", "02"],
+  ["00", "03", "04", "04", "04", "04", "05", "05", "06", "05", "02", "02", "02", "02", "02"],
+  ["07", "03", "03", "03", "03", "04", "06", "06", "06", "06", "06", "06", "06", "02", "02"],
+  ["07", "07", "07", "03", "03", "04", "04", "06", "08", "08", "08", "06", "02", "02", "02"],
+  ["07", "07", "03", "03", "03", "04", "04", "08", "08", "08", "08", "06", "06", "06", "02"],
+  ["07", "07", "07", "07", "07", "08", "08", "08", "09", "09", "08", "06", "08", "06", "02"],
+  ["10", "10", "07", "07", "09", "09", "09", "09", "09", "09", "08", "08", "08", "11", "02"],
+  ["10", "10", "07", "09", "09", "09", "09", "09", "09", "09", "09", "08", "08", "11", "02"],
+  ["10", "09", "09", "09", "12", "12", "12", "13", "09", "09", "11", "11", "11", "11", "11"],
+  ["10", "10", "10", "09", "12", "12", "12", "13", "09", "11", "11", "11", "13", "13", "11"],
+  ["14", "15", "10", "12", "12", "16", "17", "13", "13", "11", "13", "13", "13", "13", "11"],
+  ["14", "15", "10", "12", "16", "16", "17", "17", "13", "13", "13", "13", "13", "13", "11"],
+  ["14", "15", "15", "12", "16", "16", "17", "17", "17", "17", "17", "13", "13", "13", "13"]
+])
+top = np.array([6, 6, 9, 5, 3, 8, 9, 3, 1, 4, 4, 1, 4, 8, 5])
+side = np.array([0, 10, 6, 4, 4, 1, 5, 8, 2, 6, 5, 11, 4, 3, 7])
+binst = solver.Board(board=board, top=top, side=side)
+solutions = binst.solve_and_print()
+```
+**Script Output**
+
+```python
+Solution found
+[[' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ']
+ ['R' 'L' 'D' 'R' 'L' 'R' 'L' ' ' ' ' ' ' ' ' ' ' 'D' 'R' 'L']
+ [' ' ' ' 'U' ' ' ' ' 'R' 'L' ' ' ' ' ' ' ' ' ' ' 'U' 'R' 'L']
+ ['D' ' ' ' ' ' ' ' ' 'R' 'L' ' ' ' ' 'D' ' ' ' ' ' ' ' ' ' ']
+ ['U' ' ' ' ' ' ' ' ' 'R' 'L' ' ' ' ' 'U' ' ' ' ' ' ' ' ' ' ']
+ [' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'D' ' ']
+ [' ' ' ' 'D' ' ' ' ' ' ' 'R' 'L' ' ' 'D' ' ' ' ' ' ' 'U' ' ']
+ [' ' 'D' 'U' ' ' 'R' 'L' ' ' ' ' ' ' 'U' ' ' 'R' 'L' 'D' ' ']
+ [' ' 'U' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 'U' ' ']
+ [' ' ' ' 'R' 'L' ' ' ' ' ' ' ' ' ' ' ' ' 'D' ' ' 'R' 'L' 'D']
+ [' ' ' ' 'D' ' ' ' ' ' ' 'R' 'L' ' ' ' ' 'U' ' ' ' ' ' ' 'U']
+ ['D' 'D' 'U' 'R' 'L' 'D' 'D' 'R' 'L' ' ' ' ' ' ' ' ' 'R' 'L']
+ ['U' 'U' ' ' ' ' ' ' 'U' 'U' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ']
+ [' ' ' ' 'R' 'L' ' ' ' ' ' ' ' ' ' ' ' ' 'D' ' ' ' ' ' ' ' ']
+ ['R' 'L' 'R' 'L' ' ' 'R' 'L' ' ' ' ' ' ' 'U' ' ' ' ' ' ' ' ']]
+Solutions found: 1
+status: OPTIMAL
+Time taken: 0.01 seconds
+```
+
+**Solved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/stitches_solved.png" alt="Stitches solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -2343,3 +2428,4 @@ Issues and PRs welcome!
 [25]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/chess_range#chess-melee-puzzle-type-25 "puzzle_solver/src/puzzle_solver/puzzles/chess_range at master · Ar-Kareem/puzzle_solver · GitHub"
 [26]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/thermometers "puzzle_solver/src/puzzle_solver/puzzles/thermometers at master · Ar-Kareem/puzzle_solver · GitHub"
 [27]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/aquarium "puzzle_solver/src/puzzle_solver/puzzles/aquarium at master · Ar-Kareem/puzzle_solver · GitHub"
+[28]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/stitches "puzzle_solver/src/puzzle_solver/puzzles/stitches at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.3.dist-info → multi_puzzle_solver-0.9.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-puzzle_solver/__init__.py,sha256=sOawTTp0FlKJI45RevxucH2ktl_9MbY5xem8txM8vSk,1967
+puzzle_solver/__init__.py,sha256=J4CxLjjSv2Lbfk5spsG42NR1JcQNrspGpt7Yz3EIx9o,2038
 puzzle_solver/core/utils.py,sha256=3LlBDuie_G0uSlzibpQS2ULmEYSZmpJXh1kawj7rjkg,3396
 puzzle_solver/core/utils_ortools.py,sha256=qLTIzmITqmgGZvg8XpYAZ4c-lhD5sEDQfS8ECdQ_dkM,3005
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
@@ -24,6 +24,8 @@ puzzle_solver/puzzles/pearl/pearl.py,sha256=AP0whWwwZ-1zKingW14OwseYylNAr6NkXSrv
 puzzle_solver/puzzles/range/range.py,sha256=g6ZuHuulYLpNFsqbnPoIB5KoGPllYppU10-Zzqfj5f8,6993
 puzzle_solver/puzzles/signpost/signpost.py,sha256=D19ua8rVwO6sgXq4nVLkZfEyz8hqc6qMOk3j-g44soU,3931
 puzzle_solver/puzzles/singles/singles.py,sha256=kwMENfqQ-OP3YIz5baY6LRcvYCsNfhImEXN00lwazKM,5658
+puzzle_solver/puzzles/stitches/stitches.py,sha256=YvT9WXvUMPLcFGOYXWIPyifCi6caZqRqBTuCgNmcTPQ,6662
+puzzle_solver/puzzles/stitches/parse_map/parse_map.py,sha256=_BcYXtDCieKaPOpjG8BFHaFIkbYvMyuwzLL-TmjFZ2k,8786
 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
@@ -31,8 +33,8 @@ puzzle_solver/puzzles/towers/towers.py,sha256=QvL0Pp-Z2ewCeq9ZkNrh8MShKOh-Y52sFB
 puzzle_solver/puzzles/tracks/tracks.py,sha256=VnAtxBkuUTHJYNXr1JGg0yYzJj3kRMBi8Nz7NHKS94A,9089
 puzzle_solver/puzzles/undead/undead.py,sha256=ygNugW5SOlYLy6d740gZ2IW9UJQ3SAr9vuMm0ZFr2nY,6630
 puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUyNhGSAu7cQ,3827
-puzzle_solver/utils/visualizer.py,sha256=ImerGaFuWpuQqtb3infQ9__mFAHdf7ibEMYYxmIOLA0,4958
-multi_puzzle_solver-0.9.3.dist-info/METADATA,sha256=KNUafonxjZw4KLdoe2kwtVn1asnbQmu1nS1JnX22zfM,113408
-multi_puzzle_solver-0.9.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.3.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.3.dist-info/RECORD,,
+puzzle_solver/utils/visualizer.py,sha256=0DP3qs4RC0FDxHNBwPFjk6Y1RDvmLdI1jVFpYweCC00,5878
+multi_puzzle_solver-0.9.4.dist-info/METADATA,sha256=4eFPtWAt3CIxMTbbJVZDxU5NCQie7QlXqfAlkNWR3lc,117546
+multi_puzzle_solver-0.9.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.4.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.4.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -18,6 +18,7 @@ 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.stitches import stitches as stitches_solver
 from puzzle_solver.puzzles.sudoku import sudoku as sudoku_solver
 from puzzle_solver.puzzles.tents import tents as tents_solver
 from puzzle_solver.puzzles.thermometers import thermometers as thermometers_solver
@@ -28,4 +29,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.3'
+__version__ = '0.9.4'

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -0,0 +1,209 @@
+"""
+    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
+import numpy as np
+import matplotlib.pyplot as plt
+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
+    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')

puzzle_solver/puzzles/stitches/stitches.py

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

puzzle_solver/utils/visualizer.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
+import argparse
 from typing import Any, Mapping, Tuple
+import json
+import sys
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
@@ -9,13 +12,12 @@ RGB = Tuple[int, int, int]
 def render_board_image(
     board: np.ndarray,
     colors: Mapping[Any, RGB],
-    output_filename: str,
     cell_size: int = 64,
     grid: bool = True,
     bg_default: RGB = (240, 240, 240),
     text_color: RGB = (0, 0, 0),
     padding: int = 20,
-) -> None:
+    ) -> None:
     """
     Render a 2D numpy array as a colored grid image with centered text labels.
 
@@ -23,7 +25,6 @@ def render_board_image(
         board: 2D numpy array (dtype can be object/str/int/etc.). Each cell's value
                is looked up in `colors` for its fill color.
         colors: Dict-like mapping from cell values to RGB tuples (0-255).
-        output_filename: Where to save the image (e.g., 'board.png').
         cell_size: Square side length (pixels) for each cell.
         grid: Whether to draw grid lines around cells.
         bg_default: Fill color when a cell's value is not in `colors`.
@@ -76,33 +77,58 @@ def render_board_image(
                 ty = y0 + (cell_size - th) / 2
                 draw.text((tx, ty), text, fill=text_color, font=font)
 
-    img.save(output_filename)
+    img.show()
 
 
+
+
+
+def get_input():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--read_stdin', action='store_true')
+    args = parser.parse_args()
+    if args.read_stdin:
+        # read from stdin until the line starts with "output json: "
+        print('reading board from stdin until the line starts with "output json: "')
+        json_path = None
+        while True:
+            line = sys.stdin.readline()
+            if line.startswith('output json: '):
+                json_path = line.split('output json: ')[1].strip()
+                break
+        with open(json_path, 'r') as f:
+            board = np.array(json.load(f))
+        print(f'read board from {json_path}')
+    else:
+        # with open('src/puzzle_solver/puzzles/stitches/parse_map/input_output/MTM6OSw4MjEsNDAx.json', 'r') as f:
+        #     board = np.array(json.load(f))
+        board = np.array([
+            ['01', '123', '01', '01', '02', '02', '02', '03', '03', '03', '03', '04', '05', '05', '05'],
+            ['01', '02', '02', '02', '02', '06', '07', '07', '03', '08', '03', '04', '04', '05', '09'],
+            ['01', '01', '02', '11', '06', '06', '06', '12', '12', '08', '13', '13', '13', '09', '09'],
+            ['01', '11', '11', '11', '14', '06', '06', '12', '12', '15', '15', '13', '09', '09', '09'],
+            ['01', '01', '11', '11', '14', '12', '12', '12', '16', '16', '15', '13', '13', '17', '09'],
+            ['01', '11', '11', '14', '14', '12', '42', '42', '42', '15', '15', '13', '13', '17', '18'],
+            ['01', '11', '11', '14', '14', '12', '12', '43', '15', '15', '20', '13', '13', '17', '18'],
+            ['01', '01', '11', '19', '19', '19', '43', '43', '44', '20', '20', '20', '13', '17', '18'],
+            ['01', '22', '23', '23', '23', '19', '43', '21', '21', '24', '24', '24', '25', '17', '17'],
+            ['22', '22', '22', '23', '19', '19', '26', '24', '24', '24', '28', '28', '25', '17', '33'],
+            ['22', '22', '23', '23', '27', '27', '26', '26', '24', '24', '29', '29', '25', '25', '33'],
+            ['22', '22', '35', '27', '27', '26', '26', '26', '26', '30', '30', '30', '25', '34', '34'],
+            ['37', '22', '35', '35', '35', '35', '35', '26', '26', '30', '31', '31', '32', '32', '40'],
+            ['37', '37', '37', '36', '36', '35', '26', '26', '26', '40', '40', '40', '40', '40', '40'],
+            ['37', '37', '37', '37', '35', '35', '38', '38', '39', '39', '40', '40', '40', '41', '41'],
+        ])
+    return board
+
 if __name__ == '__main__':
-    board = np.array([
-        ['01', '01', '01', '01', '02', '02', '02', '03', '03', '03', '03', '04', '05', '05', '05'],
-        ['01', '02', '02', '02', '02', '06', '07', '07', '03', '08', '03', '04', '04', '05', '09'],
-        ['01', '01', '02', '11', '06', '06', '06', '12', '12', '08', '13', '13', '13', '09', '09'],
-        ['01', '11', '11', '11', '14', '06', '06', '12', '12', '15', '15', '13', '09', '09', '09'],
-        ['01', '01', '11', '11', '14', '12', '12', '12', '16', '16', '15', '13', '13', '17', '09'],
-        ['01', '11', '11', '14', '14', '12', '42', '42', '42', '15', '15', '13', '13', '17', '18'],
-        ['01', '11', '11', '14', '14', '12', '12', '43', '15', '15', '20', '13', '13', '17', '18'],
-        ['01', '01', '11', '19', '19', '19', '43', '43', '44', '20', '20', '20', '13', '17', '18'],
-        ['01', '22', '23', '23', '23', '19', '43', '21', '21', '24', '24', '24', '25', '17', '17'],
-        ['22', '22', '22', '23', '19', '19', '26', '24', '24', '24', '28', '28', '25', '17', '33'],
-        ['22', '22', '23', '23', '27', '27', '26', '26', '24', '24', '29', '29', '25', '25', '33'],
-        ['22', '22', '35', '27', '27', '26', '26', '26', '26', '30', '30', '30', '25', '34', '34'],
-        ['37', '22', '35', '35', '35', '35', '35', '26', '26', '30', '31', '31', '32', '32', '40'],
-        ['37', '37', '37', '36', '36', '35', '26', '26', '26', '40', '40', '40', '40', '40', '40'],
-        ['37', '37', '37', '37', '35', '35', '38', '38', '39', '39', '40', '40', '40', '41', '41'],
-    ])
+    board = get_input()
     # rcolors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (0, 255, 255), (255, 0, 255), (255, 255, 255), (128, 128, 128)]
-    vs =[0, 255]
+    vs =[0, 128, 255]
     rcolors = [(v1, v2, v3) for v1 in vs for v2 in vs for v3 in vs if (v1, v2, v3) != (0, 0, 0)]
     nums = set([c.item() for c in np.nditer(board)])
-    colors = {i: rcolors[int(i) % len(rcolors)] for i in nums}
+    colors = {c: rcolors[i % len(rcolors)] for i, c in enumerate(nums)}
     print(nums)
     print('max i:', max(nums))
     print('skipped:', set(range(int(max(nums)) + 1)) - set(int(i) for i in nums))
-    render_board_image(board, colors, 'board.png')
+    render_board_image(board, colors)