maze | simple JavaScript utility for drawing mazes | Graphics library

I see at least these issues in your code:

• The wall is built at a random position without taking into account the odd/even division of your cells in potential-wall / not-wall cells (which is the reason why you had this.COLS = this.width*2+1 in the constructor). As a consequence your walls can end up adjacent to eachother, leaving no room for open cells. You should only place horizontal walls at even Y-coordinates, and vertical walls at even X-coordinates.

• The door in the wall is always made at the extreme end of the wall, while the algorithm should make the gap in that wall randomly.

• There is only one recursive call, which means the algorithm is not aware of the fact that a wall generally divides the room into two partitions, each of which should (generally) be further divided up through recursion. So you need two recursive calls instead of one.

If you correct those points it could work. However, I prefer a data structure where really each inner array element represents a cell, and the walls are inferred by properties of those cells. So, no cells will function as wall. Each cell then can track which are its neighbors (4 at the most). A wall can then be implemented by removing a neighbor from a cell (and doing the same in the reverse direction). The visualisation of a wall can then be done with border CSS styling.

Here is an implementation:

The problem seems a bit overwhelming: infinitely many infinite mazes, such that we can restrict ourselves to a multitude of different bounds (say, if we wanted a roughly 1 million x 1 million square) and still have unique paths between any two spaces (and your other conditions). Let's break this down into smaller pieces.

Suppose we could construct a 7 by 7 square maze-block, and were able to make a border of walls around it, with one or two gates on this border where we wanted. Then all we'd have to do is connect these square blocks in a spiral: a central square with one gate at the top, and a counterclockwise spiral of blocks with two gates each, in the direction of the spiral:

(Each numbered box is a 7x7 maze)

There's two general cases:

• 'Straight' pieces, where the two gates are on opposite sides, and
• 'Corner' pieces, where the spiral turns and gates are on adjacent sides.

We want to make these pieces generic, so we can mix and match mazes and have them fit together. To do this, we'll use this template:

1. Border Rule: The bottom and left sides of each square are all walls, except in the center of each side.
2. Free space Rule: Unless required by rules 1 or 3, no walls are allowed in the top and right sides of a maze square.
3. Gate Rule: Where two mazes meet, if the meeting is part of the spiral, both center sides will be open (in other words, crossings happen in the center of the borders). Otherwise, the maze which is below or to the left of the other shall have a wall in the center of this border.

That's a lot, so let's see an example. Here we have a template for a 'straight' horizontal connector, highlighted in blue (all mazes are 7 by 7). X means wall, O means required to be open (a crossing point/open gate between two mazes). Red X's are the border from rule 1, purple X's are blocked gates from rule 3.

The center 5 by 5 of each maze is customizable. We must ensure that there are no inaccessible squares or equal 2x2 within our maze only, since the rules above guarantee this is true where mazes meet.

One possible maze to fit the above template (there are many):

For an example of a corner piece:

I've similarly drawn examples of each possible connection to make sure it's always possible: there are many possible ways to do this for each piece type (including the special center piece).

Now, for how to generate infinitely many infinite mazes based on a seed. Suppose you created at least 2 examples of each connection piece (there are 2 straight connectors and 4 corners), although you can just make one of each and reflect it. (Really you only need 2 different examples of one connection type.)

Given any seed binary string, e.g. 10110, let this denote our choices of which example piece to use while we make the maze spiral, counting up as in the first picture. A '0' means means use our 1st example for this connector; a '1' means we use the second. You can then repeat this/extend the binary string infinitely (10110 10110 ...). Since this is periodic, we can, using some math, figure out the piece type at any point in the sequence.

I've left out the math for the pattern of connection types: this is easy to work out for a counterclockwise spiral. Given this pattern, and a convention that the point x,y = (0,0) is the bottom left corner of the spiral-start-maze-block, you can work out 'wall or space' for arbitrary x and y. This maze is infinite: you can also restrict the borders to any full odd square of mazes in the spiral, i.e. (7*(2n+1))^2 cells for positive n.

This framework pattern for a maze is customizable, but not very difficult to solve, as the regularity means you only need to solve it locally. There's nothing special about 7; any odd number at least 7 should work equally well with the same rules, if you want to make local maze blocks larger and more complex.

This code works fine when you define block_sizex, block_sizey, wall_width, wall_height.

e.g.

I have made some research and I had activate the "instance mode".

see https://p5js.org/reference/#/p5/p5

Here is how I solved my issue:

index.html -> creating divs that will each contain a separate sketch.

Swing is a single Thread library. All painting tasks are executed by the EDT.
Running long processes (such path finding) on the EDT keeps it busy, so it does not do update the gui (gui becomes unresponsive, freezes).
Run the long process on a different thread, but remember that all Swing gui updates needs to be done by the EDT.
The different thread is where you can apply a delay for slowing down the process for better visualization.
A good tool to perform such tasks is a SwingWorker.
You can find an example demonstrating the basic structure here.

If you only want to do incremental painting which does not involve long processes you can use a Swing Timer:

Call m.create_maze() in a loop before the application loop. Terminate the loop when len(m.stack) == 0:

The if-else expression requires both parts. You can nest the expressions, so something like if c1 then a else if c2 then b else c.

Canny is an edge detector. It detects the lines along which color changes. A line in your input image has two such transitions, one on each side. Therefore you see two parallel lines on each side of a line in the image. This answer of mine explains the difference between edges and lines.

So, you shouldn’t be using an edge detector to detect lines in an image.

If a simple threshold doesn't properly binarize this image, try using a local threshold ("adaptive threshold" in OpenCV). Another thing that works well for images like these is applying a top hat filter (for this image, it would be a closing(img) - img), where the structuring element is adjusted to the width of the lines you want to find. This will result in an image that is easy to threshold and will preserve all lines thinner than the structuring element.