cellular | Cellular automaton experiments in Rust

So here is the solution, what was necessary was adding the correct Pen Settings.

To check whether the device is connected or not, you can use NWPathMonitor, like this:

which one is faster?

Depends. Either one, depending on how you use them. You can find out whether one is measurably faster than the other by... measuring.

They both use fundamentally the same abstract data structure, and have the same asymptotical complexity for all operations.

according to my surface-level knowledge of vectors, a vector has to be re-allocated everytime you push_back()

Your knowledge is incorrect. A std::vector has to only be reallocated when the capacity of the vector is exceeded, which isn't everytime you push_back. Same appilies to std::string

Turns out I just needed to add location to the last part:

Is there any algorithm to calculate [a particular cell's] stabilized value without looping the whole infinite grid?

For this particular CA rule, yes, sort of. In particular, you can almost surely determine the final stable state of any given cell on the lattice by inspecting only a finite number of surrounding cells. However, the number of cells you may need to inspect can be arbitrarily large.

First, let me note that the life-like cellular automaton rule code "B5678/S45678" denotes a "majority vote" rule where the state of each cell on the next time step is the current majority state among the nine cells comprised of itself and its eight neighbors.

This rule happens to satisfy a monotonicity property: flipping the initial state of one or more cells from "off" to "on" cannot cause the future state of any cell to flip from "on" to "off", or vice versa. In other words, the future state of the lattice is a monotone increasing function of the current state.

This monotonicity has some important consequences. In particular, it implies that if you have a cluster of cells in the "on" state that is surrounded on all sides by cells in the "off" state (or vice versa), and if this cluster is currently stable (in the sense that applying the CA update rule once will not lead to any cells in the cluster changing state), then it will in fact be forever stable regardless of what else happens elsewhere on the lattice.

This is because the only way that events elsewhere could possibly affect the cluster is by changing the state of one or more cells surrounding it. And since all those surrounding cells are in the "off" state while the cells in the cluster are in the "on" state, monotonicity ensures that changing the state of any surrounding cells to "on" cannot cause the future state of any cell in the cluster to change to "off". (Of course the same argument also applies mutatis mutandis to clusters of "off" cells surrounded by "on" cells.)

(In fact, you don't really need the cluster of "on" cells to be actually surrounded by "off" cells, or vice versa — all that's required for stability is that the cluster would be stable even if all cells surrounding it were in the opposite state.)

Thus, in general, to determine the final state of a cell it suffices to simulate the time evolution of its surrounding cells until it becomes part of such a stable cluster.

One way to do this in (almost surely) finite time is to treat the sequence of 2D lattices at successive time steps as forming a 3D lattice of stacked 2D slices, and to calculate successive "pyramid-shaped" sections of this 3D lattice consisting of the states of the central cell up to time step n, its neighbors up to time step n − 1, their neighbors up to time step n − 2, and so on. At regular intervals, examine each layer of this growing pyramid to see if any of them includes a stable cluster (in the sense described above) containing the central cells.

Assuming that the central cell in fact eventually becomes part of such a stable finite cluster (which almost all cells on a randomly initialized lattice eventually do under this rule; proof left as exercise!), this method will eventually find that cluster. However, depending on the initial states of the surrounding cells, such stabilization could take an arbitrarily long time and the final state of the cell might depend on the states of other cells arbitrarily far away.

For example, let's assume that the cell we're interested in happens to be located in a region of the lattice where the initial cell states, just by chance, are arranged like the squares on a checkerboard: the four orthogonal neighbors of each cell are in the opposite state, while the four diagonal neighbors are all in the same state as the central cell. Clearly such a checkerboard arrangement is locally stable, since each cell is (barely!) in the majority among its neighbors, but any deviations in either direction from this precarious balance around the edges of the checkerboard will propagate as a chain reaction throughout it. Thus the final stable state of any particular cell on the checkerboard will depend on the state of cells surrounding the checkerboard region, which could be arbitrarily far away.

I assume, you have full control over the Matplotlib part. So, let's try to get an image from there, which can you easily use for further image processing with OpenCV.

We start with some common contour plot as shown in your question:

You can set the levels parameter to get a single contour level. That's helpful to work on several levels individually. In the following, I will focus on levels=[1.75] (the most inner green ellipse). Later, you can simply loop through all desired levels, and perform your analyses.

For our custom contour plot, we will set a fixed x, y domain, for example [-3, 3] x [-2, 2], using xlim and ylim. So, we have known dimensions for the actual canvas. We get rid of the axes using axis('off'), and the margins around the canvas using tight_layout(pad=0). What's left is the plain canvas in full size (figure size was adjusted to (10, 5), and colors are automatically adjusted to the number of levels):

Now, we save the canvas to some NumPy array, cf. this Q&A. From there, we can perform any OpenCV operation. For finding the combined area of this level contours, we might threshold the grayscaled image, find all contours, and calculate their areas using cv2.contourArea. We sum those areas, and get the whole area in pixels. From the known canvas dimensions, we know the whole canvas area in "units", and from the image dimensions, we know the whole canvas area in pixels. So, we just need to divide the whole contour area (in pixels) by the whole canvas area (in pixels), and multiply with the whole canvas area (in "units").

That'd be the whole code:

I'm still not entirely sure what you want. Does something like this work? Note you need to install the package pandas for this (How to install pandas).

What I assume your CSV file looks like:

It's not possible to run Amazon Rekognition's logic locally on your device.

When the device is offline, you could use Firebase ML Kit, or TensorFlow Lite.

You have a race condition: You read bijective_rules[0];, but other threads at the same time might execute bijective_rules[0]++;, thereby reading and writing to that memory location. If two threads write different data to the same memory address, you have a race condition and it is random which of the two gets to decide the result. So your result will be random and non-reproducible.

If multiple threads need to increment a value in the same memory location, use the atoimic function atomic_inc. Atomic functions block the memory location while one thread is working on it, and all other threads have to wait.

To get rid of the race condition, read from one copy of the buffer (or one particular memory address) and write to a second copy (or address). This way, you never write to the memory that other concurrent threads are reading from.