Expand description
Lenia_ca
is a crate that provides core functionality for simulating the Lenia system of cellular automata. The crate was made
as a programming excersize in making a large-ish Rust project. Since this was the first proper Rust project for the author, then
the crate has some weird quirks and inefficient… perhaps even illogical ways of structuring it. In the future, the trait based
system will probably be replaced by a system using phantom data or some other way of differenciating different Lenia systems from
one-another.
For now, the general way to use the crate is to import it like you would any other Rust crate, and then use the Simulator
struct
essentially exclusively. You may also want to look into the kernels
module and growth_functions
module, as they contain a number
of useful generators and functions for Lenia systems.
A rough example of a quick-start code is below… Please note that display()
function would have to be implemented by the user.
let starting_pattern: ndarray::ArrayD<f64>; // fill with your data
let channel_shape: Vec<usize> = vec![100, 100];
let mut simulator = Simulator::<StandardLenia>::new(&channel_shape);
simulator.fill_channel(&starting_pattern, 0);
while true {
simulator.iterate();
display(get_channel_as_ref(0));
}
Types of Lenia
This version of lenia_ca
crate supports only 2 different types of Lenia systems. StandardLenia
and ExpandedLenia
types, and is
not capable of simulating types like “asymptotic” or “particle” Lenia.
Implementation notes
The working principle for StandardLenia
is the following:
- Perform a convolution operation (implemented as a FFT-based convolution) between the
channel
andkernel
of theconvolution_channel
- Each point/pixel’s value is then passed into a
growth_function
of theconvolution_channel
. - The resulting points/pixels are then multiplied by the integration step
dt
and added onto the original values in thechannel
. - The resulting points/pixels are then clamped to be in range
0..1
. This result is the next time-step of thechannel
, and would be used as the next iteration’schannel
values.
use set_kernel()
to change how the kernel looks.
use set_growth_function()
to set a specific growth function for the convolution result.
use set_dt()
to change the integration-step of the simulation.
Image of the algorithm available on Github
The working principle for ExpandedLenia
is the following:
- For each
convolution_channel
, perform a convolution operation (implemented as a FFT-based convolution) between a sourcechannel
and theconvolution_channel
’skernel
. - For each
convolution_channel
, pass the convolution results into thegrowth_function
of theconvolution_channel
. - For each
channel
, perform an elementwise multiplication between the correspondingconvolution_channel
results and weights of thechannel
- For each
channel
, perform a weighted-sum on the results of the weight-convolution multiplicated results. - For each
channel
, multiply the weighted-sum by the integration stepdt
and add it to the original values in thechannel
. - For each
channel
, clamp the resulting values to be in range0..1
. This result is the next time-step of the correspondingchannel
, and would be used as the next iteration’schannel
values.
Image of the algorithm available on Github
use set_channels()
to set the number of channels in the simulation.
use set_convolution_channels()
to set the number of kernels and the associated growth functions.
use set_convolution_channel_source()
to set the channel which will be convoluted by a particular kernel.
use set_kernel()
to change how a convolution_channel
’s kernel looks like.
use set_growth_function()
to set a specific growth function for the convolution result.
use set_weights()
to set a channel’s weights for the corresponding convolution channel results.
use set_dt()
to change the integration-step of the simulation.
Modules
- A collection of often used growth functions.
- Collection of generators for often used kernel shapes.
- Collection of different types of Lenia systems.
Structs
- A single channel in a Lenia simulation.
- A single kernel-growth function pair in a Lenia simulation.
- N-dimensional kernel.
- A Lenia simulation.
Traits
- Lenia functionality trait.
Functions
- Export a frame as a png or a bunch of png-s if multidimensional.
- Extract data from n-dimensional array into a 2-dimensional array.
- Loads a png into an
ndarray
.