first commit

.gitignore

@@ -0,0 +1 @@
+__pycache__

app.py

@@ -0,0 +1,146 @@
+import streamlit as st
+from streamlit_drawable_canvas import st_canvas
+from PIL import Image, ImageDraw
+import matplotlib.colors
+import pandas as pd
+import numpy as np
+from flow_game_solver import (
+    validate_board_and_count_colors,
+    initiate_model_with_param,
+    solve_model,
+)
+
+# use canvas for user input, read the input, and connect those dots!!
+
+
+def position_to_index(x, y, width, height, rows, columns):
+    return int(x / (width / columns)), int(y / (height / rows))
+
+
+def convert_json_to_board(
+    data: pd.DataFrame, width: int, height: int, rows: int, columns: int
+):
+
+    board = np.zeros((columns, rows))
+    circleIdList = {}
+    for _, row in data.iterrows():
+        x, y = row["left"] + row["radius"], row["top"]
+        idx, idy = position_to_index(int(x), int(y), width, height, rows, columns)
+
+        circleId = row["stroke"]
+        if circleId == "#ffffff":
+            circleIdList[row["stroke"]] = -1
+        elif circleId not in circleIdList.keys():
+            circleIdList[row["stroke"]] = len(circleIdList) + 1
+
+        board[idx, idy] = circleIdList[row["stroke"]]
+
+    return board.T.astype(int).tolist()
+
+
+def draw_grid(img: Image, columns: int, rows: int):
+
+    width = img.width
+    height = img.height
+
+    draw = ImageDraw.Draw(img)
+    for col in range(columns):
+        x = (width / columns) * (col + 1)
+        draw.line((x, 0, x, height), fill=128)
+
+    for row in range(rows):
+
+        y = (width / rows) * (row + 1)
+        draw.line((0, y, width, y), fill=128)
+
+    return img
+
+
+st.title("Connect the dots")
+
+WIDTH = 300
+HEIGHT = 300
+
+col1, col2, col3 = st.columns(3)
+with col1:
+    COLUMNS = st.number_input("Columns", min_value=1, max_value=100, value=3)
+with col2:
+    ROWS = st.number_input("Rows", min_value=1, max_value=100, value=3)
+with col3:
+    fill = st.slider("Fill", min_value=0.0, max_value=1.0, value=1.0)
+waitLimit = st.number_input(
+    "Max wait time in seconds", value=1, min_value=1, max_value=100
+)
+
+bg_image = Image.fromarray((np.ones((HEIGHT, WIDTH, 3)) * 0).astype(np.uint8))
+# draw = ImageDraw.Draw(bg_image)
+# draw grid
+bg_image = draw_grid(bg_image, COLUMNS, ROWS)
+# draw.line((0, 0, 100, 100), fill=128)
+
+stroke_color = st.color_picker("Point Color: ", "#eab")
+# Create a canvas component
+canvas_result = st_canvas(
+    # fill_color="rgba(255, 165, 0, 0.3)",  # Fixed fill color with some opacity
+    fill_color=stroke_color,  # Fixed fill color with some opacity
+    stroke_width=5,
+    stroke_color=stroke_color,
+    background_color="#eee",
+    background_image=bg_image,
+    update_streamlit=True,
+    height=HEIGHT,
+    width=WIDTH,
+    drawing_mode="point",
+    point_display_radius=min(WIDTH / COLUMNS, HEIGHT / ROWS) / 3,
+    key="canvas",
+)
+st.info("""
+Click on the board to add pair of color source(s).
+Change color for different source(s).
+Use White color for unpassable path.
+""")
+
+
+clicked = st.button("Show result")
+
+
+if clicked:
+    boardData = pd.json_normalize(canvas_result.json_data["objects"])
+
+    colors = [
+        matplotlib.colors.to_rgb(row["stroke"]) for _, row in boardData.iterrows()
+    ]
+    colors = list(set(colors))
+    colors.insert(0, matplotlib.colors.to_rgb("#222"))
+
+    board = convert_json_to_board(
+        boardData,
+        WIDTH,
+        HEIGHT,
+        ROWS,
+        COLUMNS,
+    )
+
+    min_length = 0
+    max_length = 1000
+
+    num_colors, num_wall = validate_board_and_count_colors(board)
+
+    # initiate model
+    model, solution, edge = initiate_model_with_param(
+        board,
+        num_colors,
+        num_wall,
+        fill=fill,
+        area_matrix=None,
+        min_length=min_length,
+        max_length=max_length,
+    )
+
+    # solve
+    ax = solve_model(model, board, solution, edge, waitLimit, None, colors=colors)
+    if ax is not None:
+        st.pyplot(ax.get_figure())
+    else:
+        st.error("Solution does not exist")
+    # connect dots using or tools

flow_game_solver.py

@@ -0,0 +1,444 @@
+from ortools.sat.python import cp_model
+import numpy as np
+import matplotlib.pyplot as plt
+import collections
+import time
+import traceback
+import math
+import sys
+import utils as utils
+import logging
+
+
+class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):
+    """Print intermediate solutions."""
+
+    def __init__(self, board, variables, edge, test, limit, image=None):
+        cp_model.CpSolverSolutionCallback.__init__(self)
+        self.__variables = variables
+        self.__edge = edge
+        self.__solution_count = 0
+        self.__board = board
+        self.__test = test
+        self.__before = time.time()
+        self.__bg_image = image
+        self.__solution_limit = limit
+
+    def OnSolutionCallback(self):
+
+        try:
+            self.__solution_count += 1
+            logging.info("search path time: ", time.time() - self.__before)
+            solved = []
+            direction = []
+            for v in self.__variables:
+                # print("".join(str(self.Value(x)) for x in v))
+                solved.append([self.Value(x) for x in v])
+
+            for v in self.__edge:
+                color_x_y_x_y = v.split(" ")[1:]
+                color, y_prev, x_prev, y_cur, x_cur = color_x_y_x_y
+                if (x_prev != x_cur or y_prev != y_cur) and self.Value(self.__edge[v]):
+                    direction.append([color, x_prev, y_prev, x_cur, y_cur])
+            self.__before = time.time()
+
+            _ = plot_directed_solution_with_dir(
+                self.__board, np.array(solved), direction
+            )
+            logging.info("test value:", self.Value(self.__test))
+            logging.info("Draw time: ", time.time() - self.__before)
+            if self.__bg_image:
+                ax = plt.gca()
+                img = plt.imread(self.__bg_image)
+                xlim = ax.get_xlim()
+                ylim = ax.get_ylim()
+                ax.imshow(img, extent=[xlim[0], xlim[1], ylim[0], ylim[1]])
+
+            ax.figure.savefig(
+                f"/Users/darwinharianto/Documents/Git/git_training_lab/Notebook/pipe_proj/img_{self.__solution_count}.png"
+            )
+            # plt.show()
+            self.__before = time.time()
+            logging.info("")
+
+        except Exception as e:
+            logging.info(e)
+            traceback.print_exc()
+            raise e
+
+        if self.__solution_count >= self.__solution_limit:
+            logging.info("Stop search after %i solutions" % self.__solution_limit)
+            self.StopSearch()
+
+    def solution_count(self):
+        return self.__solution_count
+
+
+def fill_board_from_dict(S, data):
+    ax = plt.gca()
+    colors = plt.cm.tab20.colors
+
+    s_mat = np.array(S)
+    M, N = s_mat.shape[0], s_mat.shape[1]
+
+    s_tuple = ax.figure.get_size_inches() * ax.figure.dpi
+    s = (s_tuple[0] * s_tuple[1]) / (M * N)
+
+    for key in data:
+        color_item = int(key.split(" ")[1])
+
+        i = int(key.split(" ")[2])
+        j = int(key.split(" ")[3])
+        if data[key]:
+            ax.scatter(
+                j,
+                i,
+                s=s / 4,
+                color=colors[color_item] if color_item != 0 else "black",
+                marker="x",
+            )
+
+
+def plot_directed_solution_with_dir(board, S, direction, colors=plt.cm.tab20.colors):
+
+    plt.cla()
+    plt.clf()
+    ax = plt.gca()
+    M, N = np.array(S).shape[0], np.array(S).shape[1]
+
+    ax.set_ylim(M - 0.5, -0.5)
+    ax.set_xlim(-0.5, N - 0.5)
+    ax.set_aspect("equal")
+    ax.set_facecolor("black")
+    ax.set_yticks([i + 0.5 for i in range(M - 1)], minor=True)
+    ax.set_xticks([j + 0.5 for j in range(N - 1)], minor=True)
+    ax.grid(visible=True, which="minor", color="white")
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.tick_params(axis="both", which="both", length=0)
+
+    linewidth = utils.linewidth_from_data_units(0.45, ax)
+    for item in direction:
+        prev_x, prev_y = int(item[1]), int(item[2])
+        cur_x, cur_y = int(item[3]), int(item[4])
+        ax.plot(
+            [prev_x, cur_x], [prev_y, cur_y], color=colors[int(item[0])], lw=linewidth
+        )
+    print(S)
+    utils.add_walls_and_source_to_ax(ax, colors, board, linewidth**2)
+
+    return ax.figure
+
+
+def validate_board_and_count_colors(board):
+    assert isinstance(board, list)
+    assert all(isinstance(row, list) for row in board)
+    assert len(set(map(len, board))) == 1
+    colors = collections.Counter(square for row in board for square in row)
+    del colors[0]
+    neg_counter = 0
+    for color in colors:
+        if color < 0:
+            neg_counter += 1
+    for i in range(neg_counter + 1):
+        del colors[-i]
+    assert all(count == 2 for count in colors.values())
+    num_colors = len(colors)
+    assert set(colors.keys()) == set(range(1, num_colors + 1))
+
+    num_walls = len([x for sublist in board for x in sublist if x < 0])
+    return num_colors, num_walls
+
+
+def initiate_model_with_param(
+    board,
+    num_colors,
+    num_wall=0,
+    fill=1,
+    area_matrix=None,
+    min_length=0,
+    max_length=sys.maxsize,
+):
+
+    # create model
+    model = cp_model.CpModel()
+
+    # create variable for model
+    solution = [
+        [square or model.NewIntVar(0, num_colors, "") for (j, square) in enumerate(row)]
+        for (i, row) in enumerate(board)
+    ]
+    edge = {}
+    all_turn = {}
+    true = model.NewBoolVar("")
+    model.AddBoolOr(
+        [true]
+    )  # without this, there will be line connecting from endpoint to endpoint after few solutions
+
+    # make filled target variables
+    board_size = len(board) * len(board[0])
+    cus_board_size = board_size * num_colors
+    at_least_filled = math.floor((board_size - num_wall) * fill)
+
+    # make filled and turn constraint
+    not_filled = 0
+    turns = 0
+    path_length = np.zeros(num_colors).tolist()
+
+    # test variable
+    test = model.NewIntVar(-1000, 10000, "")
+
+    for color in range(1, num_colors + 1):
+        endpoints = []
+        arcs = []
+        for i, row in enumerate(board):
+            for j, square in enumerate(row):
+                if square == color:
+                    endpoints.append((i, j))
+                else:
+                    arcs.append(((i, j), (i, j)))
+                if i < len(board) - 1:
+                    if area_matrix is None:
+                        if board[i + 1][j] != -1:
+                            arcs.append(((i, j), (i + 1, j)))
+                    else:
+                        if area_matrix[i + 1][j] == color:
+                            arcs.append(((i, j), (i + 1, j)))
+                        elif area_matrix[i + 1][j] == 0:
+                            arcs.append(((i, j), (i + 1, j)))
+                if j < len(row) - 1:
+                    if area_matrix is None:
+                        if board[i][j + 1] != -1:
+                            arcs.append(((i, j), (i, j + 1)))
+                    else:
+                        if area_matrix[i][j + 1] == color or area_matrix[i][j + 1] == 0:
+                            arcs.append(((i, j), (i, j + 1)))
+                        # elif area_matrix[i][j+1] == 0:
+                        #     arcs.append(((i, j), (i, j + 1)))
+        (i1, j1), (i2, j2) = endpoints
+        k1 = i1 * len(row) + j1
+        k2 = i2 * len(row) + j2
+        arc_variables = [
+            (k2, k1, true)
+        ]  # without this, there will be line connecting from endpoint to endpoint
+
+        # make length constraint
+        path_length[color - 1] = 0
+
+        for (i1, j1), (i2, j2) in arcs:
+            k1 = i1 * len(row) + j1
+            k2 = i2 * len(row) + j2
+            edge_name = f"color_i1_j1_i2_j2 {color} {i1} {j1} {i2} {j2}"
+            edge[edge_name] = model.NewIntVar(0, 1, edge_name)
+            if k1 == k2:
+                model.Add(solution[i1][j1] != color).OnlyEnforceIf(edge[edge_name])
+                arc_variables.append((k1, k1, edge[edge_name]))
+                not_filled += edge[edge_name]
+            else:
+                model.Add(solution[i1][j1] == color).OnlyEnforceIf(edge[edge_name])
+                model.Add(solution[i2][j2] == color).OnlyEnforceIf(edge[edge_name])
+                forward = model.NewIntVar(0, 1, "")
+                backward = model.NewIntVar(0, 1, "")
+                # this clauses will force edge to be the same as forward and backward
+
+                # Default
+                model.AddBoolOr([edge[edge_name], forward.Not()])
+                model.AddBoolOr([edge[edge_name], backward.Not()])
+                model.AddBoolOr([edge[edge_name].Not(), forward, backward])
+                model.AddBoolOr([forward.Not(), backward.Not()])
+
+                arc_variables.append((k1, k2, forward))
+                arc_variables.append((k2, k1, backward))
+                path_length[color - 1] += forward + backward
+
+        for i, row in enumerate(board):
+            for j, square in enumerate(row):
+                bottom = f"color_i1_j1_i2_j2 {color} {i} {j} {i+1} {j}"
+                top = f"color_i1_j1_i2_j2 {color} {i-1} {j} {i} {j}"
+                right = f"color_i1_j1_i2_j2 {color} {i} {j} {i} {j+1}"
+                left = f"color_i1_j1_i2_j2 {color} {i} {j-1} {i} {j}"
+
+                turn_bool = model.NewIntVar(0, 1, "color_i1_j1_i2_j2")
+                all_turn[f"color_i1_j1_i2_j2 {color} {i} {j} {i} {j}"] = turn_bool
+
+                left_value = edge[left] if left in edge else true.Not()
+                right_value = edge[right] if right in edge else true.Not()
+                top_value = edge[top] if top in edge else true.Not()
+                bottom_value = edge[bottom] if bottom in edge else true.Not()
+
+                """
+                Minimal Form (with ~) = ~ab~cde + ~abc~de + a~b~cde + a~bc~de + ~a~b~e + ~c~d~e + cd~e + ab~e
+                """
+                # minimal form
+                model.AddBoolOr(
+                    [
+                        left_value,
+                        right_value.Not(),
+                        bottom_value,
+                        top_value.Not(),
+                        turn_bool,
+                    ]
+                )  # A+ ~B + C+ ~D+ ~E
+                model.AddBoolOr(
+                    [
+                        left_value,
+                        right_value.Not(),
+                        bottom_value.Not(),
+                        top_value,
+                        turn_bool,
+                    ]
+                )  # A+ ~B + ~C+ D+ ~E
+                model.AddBoolOr(
+                    [
+                        left_value.Not(),
+                        right_value,
+                        bottom_value,
+                        top_value.Not(),
+                        turn_bool,
+                    ]
+                )  # ~A+ B + C+ ~D+ ~E
+                model.AddBoolOr(
+                    [
+                        left_value.Not(),
+                        right_value,
+                        bottom_value.Not(),
+                        top_value,
+                        turn_bool,
+                    ]
+                )  # ~A+ B + ~C+ D+ ~E
+                model.AddBoolOr([left_value, right_value, turn_bool.Not()])  # A+ B + E
+                model.AddBoolOr([bottom_value, top_value, turn_bool.Not()])  # C+ D+ E
+                model.AddBoolOr(
+                    [bottom_value.Not(), top_value.Not(), turn_bool.Not()]
+                )  # ~C+ ~D+ E
+                model.AddBoolOr(
+                    [left_value.Not(), right_value.Not(), turn_bool.Not()]
+                )  # ~A+ ~B+ E
+
+                turns += turn_bool
+
+        model.Add(path_length[color - 1] < max_length)
+        model.Add(path_length[color - 1] >= min_length)
+        model.AddCircuit(arc_variables)
+
+    # model.Minimize(not_filled)
+    model.Minimize(turns + not_filled)
+    model.Add((cus_board_size - not_filled) >= at_least_filled)
+    model.Add(test == cus_board_size - not_filled)
+
+    return model, solution, edge
+
+
+def solve_model(
+    model, board, solution, edge, limit=None, image=None, colors=plt.cm.tab20.colors
+) -> plt.Axes:
+
+    # solve model
+    solver = cp_model.CpSolver()
+    solver.parameters.max_time_in_seconds = limit
+
+    asd = time.time()
+    status = solver.Solve(model)
+
+    logging.info(f"Search sol time: {time.time()-asd}")
+    # Output solution.
+    if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
+        solved = []
+        direction = []
+        for v in solution:
+            solved.append([solver.Value(x) for x in v])
+        for v in edge:
+            color_x_y_x_y = v.split(" ")[1:]
+            color, y_prev, x_prev, y_cur, x_cur = color_x_y_x_y
+            if (x_prev != x_cur or y_prev != y_cur) and solver.Value(edge[v]):
+                direction.append([color, x_prev, y_prev, x_cur, y_cur])
+
+        _ = plot_directed_solution_with_dir(board, np.array(solved), direction, colors)
+        ax = plt.gca()
+        if image:
+            img = plt.imread(image)
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+            ax.imshow(img, extent=[xlim[0], xlim[1], ylim[0], ylim[1]])
+        ax = plt.gca()
+        return ax
+
+    else:
+        logging.info("No solution found")
+        return None
+
+    # #### print multiple solution
+    # solution_printer = VarArraySolutionPrinter(board,solution, edge, test, limit, image=image)
+    # print(f"finished preparing model {time.time()-dsa}, starting search")
+    # status = solver.SearchForAllSolutions(model, solution_printer)
+    # print()
+    # print('Solutions found : %i' % solution_printer.solution_count())
+
+
+def main(
+    board,
+    fill=1,
+    min_length=0,
+    max_length=sys.maxsize,
+    limit=1,
+    image=None,
+    area_matrix=None,
+    save_path=None,
+):
+    # validate board get number of wall and colors
+    num_colors, num_wall = validate_board_and_count_colors(board)
+
+    # initiate model
+    model, solution, edge = initiate_model_with_param(
+        board,
+        num_colors,
+        num_wall,
+        fill=fill,
+        area_matrix=area_matrix,
+        min_length=min_length,
+        max_length=max_length,
+    )
+
+    # solve
+    ax = solve_model(model, board, solution, edge, limit, image, colors=plt.cm.tab20.colors)
+
+    # plt.show()
+    ax.figure.savefig(save_path) if save_path else None
+
+
+if __name__ == "__main__":
+
+    board_size = (10, 10)
+    num_of_color = 4
+
+    board = np.zeros(board_size)
+    for i in range(num_of_color):
+        center_index = (int(board_size[0] / 2) - 1, int(board_size[1] / 2) - 1)
+
+        for value in range(len(board[center_index[0]]) - 1):
+            board[center_index[0]][value] = board[center_index[0]][value + 1]
+
+        for j in range(num_of_color - 1):
+            board[center_index[0]][center_index[1] + i] = i + 1
+            board[center_index[0]][center_index[1] + 1 + i] = i + 1
+
+    board = np.array(
+        [
+            [-1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            # [0,0,0,0,0,0,0,0,0,0,0,0],
+            # [0,0,0,0,0,0,0,0,0,0,0,0],
+            # [0,0,0,0,0,0,0,0,0,0,0,0],
+            # [0,0,0,0,0,0,0,0,0,0,0,0],
+            # [0,0,0,0,0,0,0,0,0,0,0,1],
+        ]
+    )
+
+    main(
+        board.astype(int).tolist(),
+        fill=0.8,
+        min_length=0,
+        max_length=1000,
+        limit=1,
+        save_path="./res.png",
+    )

requirements.txt

@@ -0,0 +1,56 @@
+absl-py==1.3.0
+altair==4.2.0
+attrs==22.1.0
+backports.zoneinfo==0.2.1
+blinker==1.5
+cachetools==5.2.0
+charset-normalizer==2.1.1
+click==8.1.3
+commonmark==0.9.1
+contourpy==1.0.6
+cycler==0.11.0
+decorator==5.1.1
+entrypoints==0.4
+fonttools==4.38.0
+gitdb==4.0.10
+GitPython==3.1.29
+idna==3.4
+importlib-metadata==5.1.0
+importlib-resources==5.10.1
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+MarkupSafe==2.1.1
+matplotlib==3.6.2
+numpy==1.23.5
+ortools==9.5.2237
+packaging==22.0
+pandas==1.5.2
+Pillow==9.3.0
+pkgutil_resolve_name==1.3.10
+protobuf==3.20.3
+pyarrow==10.0.1
+pydeck==0.8.0
+Pygments==2.13.0
+Pympler==1.0.1
+pyparsing==3.0.9
+pyrsistent==0.19.2
+python-dateutil==2.8.2
+pytz==2022.6
+pytz-deprecation-shim==0.1.0.post0
+requests==2.28.1
+rich==12.6.0
+semver==2.13.0
+six==1.16.0
+smmap==5.0.0
+streamlit==1.15.2
+streamlit-drawable-canvas==0.9.2
+toml==0.10.2
+toolz==0.12.0
+tornado==6.2
+typing_extensions==4.4.0
+tzdata==2022.7
+tzlocal==4.2
+urllib3==1.26.13
+validators==0.20.0
+zipp==3.11.0

utils.py

@@ -0,0 +1,261 @@
+import numpy as np
+import time
+import logging
+
+
+def print_time(before):
+    logging.info(time.time() - before)
+    return time.time()
+
+
+def linewidth_from_data_units(linewidth, axis, reference="y"):
+    """
+    Convert a linewidth in data units to linewidth in points.
+
+    Parameters
+    ----------
+    linewidth: float
+        Linewidth in data units of the respective reference-axis
+    axis: matplotlib axis
+        The axis which is used to extract the relevant transformation
+        data (data limits and size must not change afterwards)
+    reference: string
+        The axis that is taken as a reference for the data width.
+        Possible values: 'x' and 'y'. Defaults to 'y'.
+
+    Returns
+    -------
+    linewidth: float
+        Linewidth in points
+    """
+    fig = axis.get_figure()
+    if reference == "x":
+        length = fig.bbox_inches.width * axis.get_position().width
+        value_range = np.diff(axis.get_xlim())[0]
+    elif reference == "y":
+        length = fig.bbox_inches.height * axis.get_position().height
+        value_range = np.diff(axis.get_ylim())[0]
+    # Convert length to points
+    length *= 72
+    # Scale linewidth to value range
+    return linewidth * (length / value_range)
+
+
+def add_walls_and_source_to_ax(ax, colors, S, scatter_size):
+
+    s_mat = np.array(S)
+    M, N = s_mat.shape[0], s_mat.shape[1]
+
+    scatter_dict = {"color_item_-1_x_y": []}
+    for iter in range(np.sum(np.unique(s_mat) > 0)):
+        scatter_dict[f"color_item_{iter+1}_x_y"] = []
+
+    for i in range(M):
+        for j in range(N):
+            if S[i][j] != 0:
+                scatter_dict[f"color_item_{S[i][j]}_x_y"].append([j, i])
+                
+    for key in scatter_dict:
+        color_item = int(key.split("_")[2])
+        mat = np.array(scatter_dict[key]).T
+        if len(mat) == 0:
+            continue
+        j = mat[0].tolist()
+        i = mat[1].tolist()
+        ax.scatter(
+            j,
+            i,
+            s=scatter_size * 2,
+            color=colors[color_item] if color_item != 0 else "black",
+            marker="x" if color_item < 0 else None,
+        )
+
+
+def plot_area(S):
+    import matplotlib
+    import matplotlib.pyplot as plt
+    from matplotlib import colors
+
+    ax = plt.gca()
+    color = [matplotlib.colors.to_hex(c) for c in plt.cm.tab20.colors]
+    s_mat = np.array(S)
+    M, N = s_mat.shape[0], s_mat.shape[1]
+
+    # create discrete colormap
+    # print(color[:s_mat.max()] + color[-1])
+    cmap = colors.ListedColormap([color[-1]] + color[: s_mat.max() + 1])
+    # cmap = colors.ListedColormap(['red', 'blue', 'green', 'yellow', 'black'])
+    bounds = [i for i in np.arange(-1, s_mat.max() + 2, 1)]
+    norm = colors.BoundaryNorm(bounds, cmap.N)
+
+    ax.imshow(s_mat + 0.5, cmap=cmap, norm=norm, alpha=0.5)  # half is for the threshold
+
+    # draw gridlines
+    ax.set_facecolor("black")
+    ax.set_ylim(M - 0.5, -0.5)
+    ax.set_xlim(-0.5, N - 0.5)
+    return ax.figure
+
+
+def plot_walls(S):
+    import matplotlib.pyplot as plt
+
+    plt.clf()
+    plt.cla()
+    ax = plt.gca()
+    colors = plt.cm.tab20.colors
+    s_mat = np.array(S)
+    M, N = s_mat.shape[0], s_mat.shape[1]
+
+    linewidth = linewidth_from_data_units(0.45, ax)
+
+    ax.set_ylim(M - 0.5, -0.5)
+    ax.set_xlim(-0.5, N - 0.5)
+    ax.set_aspect("equal")
+    ax.set_facecolor("black")
+    ax.set_yticks([i + 0.5 for i in range(M - 1)], minor=True)
+    ax.set_xticks([j + 0.5 for j in range(N - 1)], minor=True)
+    ax.grid(b=True, which="minor", color="white")
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.tick_params(axis="both", which="both", length=0)
+
+    add_walls_and_source_to_ax(ax, colors, S, linewidth)
+    logging.info("finish plot_walls for right side")
+
+    return ax.figure
+
+
+def put_num_on_matrix(m, walls, in_num):
+
+    matrix = np.copy(m)
+
+    for coords in walls:
+        x_min, x_max, y_min, y_max = coords[0], coords[2], coords[1], coords[3]
+        for x in range(
+            x_min,
+            x_max + 1 if (x_min < x_max) else x_max - 1,
+            1 if (x_min < x_max) else -1,
+        ):
+            x = int(x)
+            for y in range(
+                y_min,
+                y_max + 1 if (y_min < y_max) else y_max - 1,
+                1 if (y_min < y_max) else -1,
+            ):
+                y = int(y)
+                if y < len(matrix) and x < len(matrix[0]) and matrix is not None:
+                    matrix[y][x] = in_num
+
+    return matrix
+
+
+def put_rect_source_on_matrix(matrix, coords):
+
+    number_of_source = 0
+
+    x_min, x_max, y_min, y_max = coords[0], coords[2], coords[1], coords[3]
+
+    for x in range(
+        x_min, x_max + 1 if (x_min < x_max) else x_max - 1, 1 if (x_min < x_max) else -1
+    ):
+        x = int(x)
+        for y in range(
+            y_min,
+            y_max + 1 if (y_min < y_max) else y_max - 1,
+            1 if (y_min < y_max) else -1,
+        ):
+            y = int(y)
+            matrix[y][x] = int(number_of_source / 2) + 1
+            number_of_source += 1
+    assert number_of_source % 2 == 0 and "Number of source outlet must be mutiply of 2!"
+    return matrix
+
+
+def put_point_source_on_matrix(matrix, coords):
+
+    number_of_source = len(matrix)
+    assert number_of_source % 2 == 0 and "Number of source outlet must be mutiply of 2!"
+
+    for x, y, col in coords:
+        matrix[int(y)][int(x)] = col
+
+    return matrix
+
+
+def create_matrix_and_area_matrix(color_dict, canvas_size, pipe_size, source, arr):
+
+    matrix = np.zeros(
+        (np.array(canvas_size) / np.array(pipe_size)).astype("int").tolist()
+    ).astype("int")
+    area_matrix = None
+
+    color_set = list(set([item.split("_")[-1] for item in color_dict.keys()]))
+    for index in color_set:
+        for start_point, end_point in zip(
+            color_dict[f"start_{index}"], color_dict[f"end_{index}"]
+        ):
+            # graph.draw_rectangle(start_point, end_point, fill_color=colors[int(index)], line_color=colors[int(index)])
+
+            start = np.array(start_point)
+            end = np.array(end_point)
+
+            start[1] = canvas_size[1] - start[1]
+            end[1] = canvas_size[1] - end[1]
+            start[0], start[1], end[0], end[1] = (
+                start[0] / pipe_size[0],
+                start[1] / pipe_size[1],
+                end[0] / pipe_size[0],
+                end[1] / pipe_size[1],
+            )
+            arr = (
+                np.append(arr, [np.append(start, end)], axis=0)
+                if arr is not None
+                else np.append(start, end).reshape(-1, 4)
+            )
+
+        # this means wall
+        if int(index) == -1:
+            matrix = put_num_on_matrix(matrix, arr, in_num=-1)
+        area_matrix = (
+            put_num_on_matrix(area_matrix, arr, in_num=int(index))
+            if area_matrix is not None
+            else put_num_on_matrix(matrix, arr, in_num=int(index))
+        )
+        arr = None
+
+    if source:
+        if len(source[0]) == 2:
+            start_x = source[0][0] / pipe_size[0]
+            end_x = source[1][0] / pipe_size[0]
+            start_y = (canvas_size[1] - source[0][1]) / pipe_size[1]
+            end_y = (canvas_size[1] - source[1][1]) / pipe_size[1]
+            source_sized = np.array([start_x, start_y, end_x, end_y]).astype("int")
+            matrix = put_rect_source_on_matrix(matrix, source_sized)
+        elif len(source[0]) == 3:
+            source_sized = []
+            for i in range(len(source)):
+                x = source[i][0] / pipe_size[0]
+                y = (canvas_size[1] - source[i][1]) / pipe_size[1]
+                col = source[i][2]
+                source_sized.append([x, y, col])
+
+            matrix = put_point_source_on_matrix(matrix, source_sized)
+
+    return matrix, area_matrix
+
+
+if __name__ == "__main__":
+    matrix = [
+        [-1, 0, 1, 1],
+        [-1, 0, 2, 2],
+        [-1, 0, 0, 0],
+    ]
+    areamatrix = [
+        [-1, 0, 1, 1],
+        [-1, 0, 1, 1],
+        [-1, 0, 2, 2],
+    ]
+    plot_walls(matrix)
+    plot_area(areamatrix)
+    pass