Example Code
Code and Documents
Attachment
In this example we'll look at 3 VIs created to simulate a cellular automaton (http://en.wikipedia.org/wiki/Cellular_automaton).
The primary VI (CellularAutomataSimulation.vi) can be run to simulate the automaton. It requires NI Vision (which is used to allow you to record the activity to an AVI file) to run, but you can delete the sections of code that reference IMAQ you'll be able to run it without.
The secondary VI (SimpleAutomata.vi) runs on the automaton data, executing the rule on each element of the matrix and outputting the next state.
The helper VI (ModifyMatrix.vi) is used to do simple addition and subtraction to the automaton (it interfaces with the mouse so you can artifically add energy to the system). Interestingly enough, LabVIEW does not coerce the values for addition and subtraction to 0 and Max_Int. This performs the coercion manually.
The code seems a bit complex because of the interface with the mouse and the controls on the front, but it really comes in 2 steps, a setup and a loop.
The setup
randomly initializes an array of the size specified with Unsigned 32-bit integers.
The primary application happens in the subVI within the application loop.
Most of the code is obviously part of different systems which make the program more user friendly (and unfortunately, the code rather difficult to read at times). Although some of the code could be split into subVIs, the application is simple enough that this was not implemented. If further expansion is to be done other than writing new Automaton Rules (which are obviously in a SubVI), it may be worth modifying the code for readability.
There are a couple different things that can be learned from this example.
-Cellular Automaton Processing
-Image Manipulation
-Mouse Input
-AVI Creation
If you have the patience to let it run, you can also observe round-off error in action. The automaton in use will eventually converge to 0 with no wrapping and no mouse clicks. If you allow the automaton to run until it is no longer changing from step to step (requires an extra comparison which is no in the program, but if you leave it over night and eyeball it it'll be done) it will have a blue coloring. This is because the levels of each number are low enough that their averages round off and can never be dissipated.
Interesting questions and futher experiments (some of which I've done, but won't spoil the answers if you don't already know):
-Why do the colors seem to have 3 distinct layers? (Red then Green then Blue)
-Why does the phenomena on the walls happen when wrapping is enabled?
-What is the significance of the waves that propagate towards given points on the image?
-Will the system always converge to 0? How would you modify to the rule to make it converge to MaxInt? Can you modify it to not converge to either?
-Try adding a rule of your own (see http://en.wikipedia.org/wiki/Conway's_Game_of_Life)
-Try adding a color mask to manipulate the way the data is represented.
And the most important question,
-What's the point of a Cellular Automaton? (my answer, they're cool)
(Added a version without the IMAQ components.)
Example code from the Example Code Exchange in the NI Community is licensed with the MIT license.
