LParser Evolution Engine (c) 1998 Robert Gasch
LPEvol was written by Robert Gasch (Robert_Gasch@peoplesoft.com) and is copyright by the author. LPEvol is available from various FTP sites (most notably the Linux section of sunsite.unc.edu ) as well as the author's software page, which is:
http://www.peoplesoft.com/peoplepages/g/robert_gasch/src/
Permission to use, copy, modify and distribute this software for any purpose and without fee is hereby granted, provided that this copyright notice appear in all copies as well as supporting documentation. All work developed as a consequence of the use of this program should duly acknowledge such use.
See the GNU General Public Licence for more information.
LPEvol should work all right but
No representations are made about the suitability of this software for any purpose. This software is provided "as is" without express or implied warranty.
LPEvol stands from LParser Evolution (Engine) . It is a Java application which allows you to interactiveley breed LSystems objects and view the results graphically. The idea for such a program originates (as far as I know) from Richard Dawkins' The Blind Watchmaker. While LPEvol doesn't have anything to do with the biomorphs mentioned in Dawkins' book, it uses the same universal concepts of selection and genetic breeding but applies them to a population of LParser objects.
Note: LPEvol is a java application, not a java applet.
LSystems are (recursive) mathematical models that can be used to describe growth patters modelling the shapes we see around us every day, like trees, flowers and many others. LPEvol is an application which uses LParser and PovRay to generate and draw these LSystems. You as the user then have the choice to select the LSystems you like and then breed them (doing a crossover, using the Genetic Algortihm) to produce a next generation (the children ) which will have been derived from the formulas ( genes ) describing the parents. In fact you could describe LPEvol as a semi-random, user driven tool to survey the vast search space LSystems offer. You can see screen shots of what this means here over a series of 5 generations using the default shipped set of LSystems: Generation 1 , Generation 2 , Generation 3 , Generation 4 , Generation 5 .
LPEvol was developed under LINUX and should run under any UNIX type system which has the required support software installed.
The current version number is 0.54. This implies that this version is a first public release of LPEvol and that you should not be all too surprised to encounter bugs. At this point LPEvol seems pretty stable when run with the default breeding parameters, but it's entireley possible that underneath that docile shell, you'll encouter unexpected exception throwing monsters. If you do run into these, I'd appreciate a mail describing the symptoms (or better yet, since you have the source, you can mail me the fix :-) ). I would welcome any input, suggestions, fixes or comments you might have on LPEvol.
The current status is that I wrote LPEvol almost a year ago on a whim, thereby interrupting another project I was working on. Once LPEvol was reasonably stable I made it available. Since then, work has been busy and I've been (somewhat) lazy. That other project is finally progressing along niceley so that I'll be able to take a look at LPEvol again sometime reativeley soon. I will update LPEvol to use JDK 1.2, add a few more features and stomp out any bugs I encounter.
LPEvol builds on a number of software pieces. Here's a list of the programs you need:
LPEvol was developed on my LINUX machine, please realize that some of the following information is UNIX specific and all of it is very PC specific.
LPEvol is a resource-intensive appliation. While in theory it may run on all sorts of ancient hardware I would think that for reasonable performace you need at least something like a Pentium 166 with 64MB of Ram and probably at least another 64MB of swap space. You also need at least 20-30M working hard disk space available. I'm running it on an AMD K6 233 with 64MB RAM and wouldn't want anything slower/smaller. I just recently upgraded it to 128MB ram and noticed that it seems much happier now when running large lsystems. Also, since it's all graphical, it's nice to have a graphics card which can do at least 16 bit color.
LPEvol uses other programs which are both CPU and memory intensive. Here's some data (as measured on my LINUX box):
If you're not sure what this means, here is a snapshot of my Linux box (AMD K6-233, 64 Meg Ram) when trying to render a 10 Meg include file with PovRay. Basically, my machine was rendered increasingly unusable as it was swapping itself to death. I ended up killing the PovRay process which had allocated almost 100MB of RAM (on top of JDK and all other sorts of processes) when my machine became increasingly sluggish and top told me that my system was using 100MB of swap and was still allocating memory for PovRay.
The default behaviour of LPEvol is to not render lsystems which result in include files bigger than 5MB. This seems to generate PovRay jobs which use around 45-50MB. If you have 64MB RAM plus sufficient swap space, your (Linux) system will be able to handle this.
If you have a system with 32MB RAM, you probably want to try the -blob and -mblob options as they produce much smaller PovRay include files (but also less visually appealing output IMHO) and may make LPEvol more usable on your machine (even though it will probably be tight).
If you're on a machine with less than 32MB RAM, you probably don't want to run LPEvol (certainly not in it's default mode) as I'm pretty sure that your machine will grind to a halt swapping itself to death.
LPEvol seems quite stable at this point. I know of two remaining bugs:
The PovRay files produced by LPEvol are scaled to <1,2,1>. This makes these files readily usable in other PovRay scenes as it provide a fixed scale by which the object(s) can be sized, thus eleminating the guesswork when trying to use a file produced by LParser.
LParser starts from size zero and then increases in size through all it's (recursive) iterations. Because of the way LParser is written (it outputs the current object right away rather than storing it and then rescaling the entire object set before writing everything in one go), it can not know the size of an object beforehand, thus (since it doesn't keep the object definitions) it's unable to do any scaling. While this is not really a problem, having to guess an object's size before being able to (meaningfully) use it in a scene file is somewhat annoying.
The PovRay output files generated by LPEvol are twofold:
When starting up LPEvol in it's default mode, it uses the current time as the seed value for the random number generator. Using the -s flag, you can specify a random number seed, thereby ensuring that you are going to follow the same execution path.
As the version number of 0.5x suggests, this is a pre-release. I haven't tried this yet, but hopefully will sometime soon. Getting it to work under Windows should not be much work though. Once you have aquired the required support programs the only question really remaining is wether PovRay behaves identically under Windows as it does under UNIX. I'm hoping for the best (in terms of command line options), but haven't looked into this yet. I hope to get around to this sometime in the near future.
If you extend LPEvol's functionality or simply solve a bug, please mail me the changes as I'd like to act as the central source for LPEvol. This will also enable me to include your changes in a future release (and give you credit for it).
Who knows? LPEdit is basically the result of 1 month of writing code and another 3 leisurly months of cleaning up the code, completing various features, testing and fixing bugs. I'll see if I get any feedback or bug reports and then see. I do however plan to eventually release a version 1.0 which should include support of the new features coming in JDK 1.2.
Type the following command at the prompt: java LPEvol To get the list of command line options use: java LPEvol -?
The Makefile contains the following useful targets:
LPEvol accepts the following parameters as command line options:
[-?|-help] help
-append _arg_ append new chromosomes with p 0..p..1
-append_replace _arg_ update old references after append with p 0..p..1
-batch run program in batch (non-interactive) mode
-blob generate single PovRay blob file
-chrom_offset _arg_ number of chromosomes to skip when breeding
-cross_after shift right when a position guess hits a number
-[libdir|L] _arg_ directory were LPEvol looks for .pov files
-limit_brackets _arg_ limit bracket mode (value modes are 0-3)
-maxincfile _arg_ maximum size of PovRay include file to be rendered
-maxgen _arg_ maximum number of generations (batch mode)
-maxreplace _arg_ maximum number of times to replace a broken org
-mblob generate multiple PovRay blob files
-mutate _arg_ number of times lparser should mutate
-nchrom_breed _arg_ # of chromosomes to breed (0<=n<=i; default=1,0=all)
-noautostart do not autostart rendering population upon startup
-noclean don't remove inlude files
-nodir don't create population subdirectories
-nogui run without gui (batch mode)
-norecycle don't recycle images (forces render)
-nowrite don't write orgs/pops to file (batch mode)
-numeric _arg_ _arg_ number of numeric params to breed and breed probability
-pfile _arg_ specify population file to read
-psize _arg_ specify population size
-quit render population and quit
-render_big render 800x600 images
-replace same as -noreplace_size and -noreplace_break");
-replace_size replace LSystems which are too big (-maxincfile)");
-replace_broken replace LSystems which break lparser or PovRay");
-rnd_nchrom breed random number of times; max = -nchrom_breed
-seed _arg_ specify random number seed
[-v|-verbose] enable verbose mode
The here are my default and my test invocation command lines:
The best thing would be to fix it yourself and send the fix to me. The next best thing is to send me email describing your problem. If you mail me, please also let me know what OS and Java VM version you are running.
If you really feel this way, how about a short mail message telling me that you are happy about using LPEvol.
If you have created something with LPEvol that you think is special, extraordinary or just plain cool, consider sending me the lparser file. If you use this file in a PovRay scene, consider sending me the resulting jpg (or scene) file(s). I would eventually like to bundle LPEvol with a greater selection of interesting LParser systems.
If for some odd reason you use LPEvol for anything that might be considered semi-serious or even serious work, I would also be interested to hear from you.
Don't use it. Don't mail me!
