Thomas Haenselmann - Software Homebrewed

>> DIESE SEITE AUF DEUTSCH << All software on this page is free. The copyright holder is Thomas Haenselmann

A particle simulation (32-bit Windows or Linux)

Windows Version

In the window of ParticleSimulation.exe you can spray an amount of particles into the air. The number of simulated particles is only limited by the speed of your PC. Even on my former Pentium II about 6000 particles could be simulated at a time in a smooth fashion. In the current version the particles don't interact with eachother however they will bounce back from the ground and they accelerate depending on a gravity constant. This constant can be changed along with a number or other parameters in a dialog box.

You can download a ziped executable of the program ready to run or the source code. Note that you have to use MS Visual Studio in order to compile the application yourself.

Beginner version with dialog box

	ParticleSimulation.zip Windows executable (136 kB)
	Source Code as Visual Studio Project (365 kB)

Fast command line version (start from dos prompt/not dos mode!)

	WinParticles-Pro Windows executable (106 kB)
	Source Code as Visual Studio Project (33 kB)

Linux Version

There was quit a bit of feedback on the particle simulation so I ported it to Linux using the SDL library (Simple Direct Media Layer). The Linux version can handle more particles than the Windows version. Unlike the first Windows Version is doesn't include a dialog box. Use command line options to control it and see "particles -h" to learn about the options.

	xparticles.zip binary Linux version 1.0 - plug and play (658 kB)
	XParticles-1.0.tar.gz (85 kB) needs the developer version of SDL

August 27th, 2002:

New Windows WinParticles-Pro Version. The Linux SDL version was ported back to Windows. Now a significantly increased number of particles can also be simulated on Windows but there is no more dialog box. So winparticles.exe has to be started from the DOS prompt.

August 25th, 2002:

The new animation mode was added. Now you can capture your moves in a textfile and play them back. Try option -y demo_movie.txt and enjoy the show :) The works only for the Linux version and WinParticles-Pro.

August 19th, 2002:

Dual processor option was added to simulate up to 100k particles on a dual Xeon 2.2 GHz (do not use it on single CPU systems since it slows them down). Source should compile better on most systems. Bugfix of well known segmentation fault.

August 10th, 2002:

Joe Thornber provided a patch that causes the emission to be circular which looks really cool. Thanks Joe.

(small extract of a screenshot)

Send me an e-mail with a capture
file for playback using the -c option

ppm2html (Linux)

ppm2html is a small linux tool that converts an RGB ppm image into a html page. The page will display an approximated version of the image only using ASCII characters and color definitions.
If a 'source string' is being defined this string will repeatedly be used as character source for rendering the ASCII output. If omitted random characters between 'a' and 'z' will be used. The 'red', 'green', 'blue' values define the backgroundcolor of the html page. If no commandline arguments are given the page is rendered black.

Best results will be obtained if segmented objects are converted (which means that the background of the image is replaced by a single color). Also the level of detail should be kept low. A small blur on the image (e. g. a gaussian filter) can result in a nicer visual appearance, especially when displaying text.
Note than the output differs among different kinds of browsers. In particular the horizontal scaling might differ a lot. Best results will probably be achieved using unique renderings for each kind of browser.

ppm2html image.ppm [source_string] [red green blue] > output.html

image.ppm	RGB image in ppm format
source_string	string used for rendering html page
	(omit for random characters from ['a','z'])
red, green, blue	html background color (omit for black)

ppm2html.zip executable (25 kB)
Source Code source code (65 kB)

(example rendered by ppm2html)

pjnbpbwllsrehfmxrkecwitrsglrexvtjm
xypunbqfgxmuvgfajclfvenhyuhuorjosamibdnjdbeyhk
bsombltouujdrbwcrrcgbflqpottpegrwvgajcrgwdlpgi
tydvhedtusippyvxsuvbvfenodqasajoyomgsqcpjlhbmd
ahyviuemkssdsldebesnnngpesdntrrvysuipywatpfoel
throwhfexlwdysvspwlkfblfdfultbwpiqhiymmyalcyea
svxggfitknygyvjxnspubqjppjbrlhugesmmxwjjlkrmgb
nwvftyveolprfdcajiuywtvgfjrwwaakwyprxnxpypjgtl
hfteetxbafkrejsfvrenlebjtccgjvrsdowiixlidxdiix
pervseavnwypdinwdrlacvanhelkovkedcaxgctwysocdd
agwnjbkjorpceeyokeskcanvyornrustephpqtbhlrkrxl
gjpavrcjpbyhosfimlavbtqcdevpwubfgshcmlofmpmekt
oyfquimnnqujgrgkymfjrsuixixmoihdhoveajsnanyihg
siuyrotnwtxwgmhprqhpvhyqwbgvmpefxagqqcgovenfsv
ummecklebihjhtylcalksfnytlfjqafoosssfhwhrfsybs
ldsyonecmantkhtrvkmqdsxdaqksrlnfpifevlikoxebfa
sdkguoyurbncvgpklfuslrhvevujwcjpiwxfnwafxojwwy
hkheesxlpdjmmiqxxywwekvhpwvbtsbddihjdgwujijxqb
xpcvojgkqyjoadjdgonobrwxmghwgaaepeagnhtggduihg
mpvaewrbwhjggphiuymwibecjmhhvqnkhlklkfpiobqura
doaplkssmdhvkfnapumdiwiahwcbtvbykdoxnkscpbycgm
cyhqcrqksxjubfqdedisdwfwyuaawimchvsjojvjkhelmw
qqcamhyrexpgbopnqwmmjdvfmgpqucpltrlibmagnroohe
eaeqmntlugtkyopobliotkcvspojgxokxucnixyffssgki
xlvicpuglpxaaeaoryjtottnbbitiseggaqlrmrecsgcyh
sqicmwxhmaiwvsqdbyfskxffejxkmytfqckfbiopixnhsg
kufpnqnuvrevfsuyynelthtkxfinmetyyboorflpyplglj
imwmxstretyojnsdmtfeiyjtpkmdtamcmmokfkelhedqrv
wfselddwauhmyboldbxtlghrrovufqtexmijrmgrjpgitu
uwvutjbbcvpaswqocqdmavyinlyutspqromnxpocngdhev
vinaupvwbjiagcuwvolidlarqoytvfrtnhtkarhbepdkux
hqmubpjbiarjvponkexgoxbybfoeplcaeqwhjgltgddctt
sgxsmosnntufxlscnxukferqxawddqwxwwqlmjcadwhdkb
hxyelgjdajdwnipkgokwawieynejqokaplfbrqetcjqpui
dbwnbamlenaiwqahtpubsptyjvidmdlrhjhkjtvpjvyhpb

Game of life (Windows 98)

Game of Life was an idea described in the journal Scientific America by a mathematician John H. Conway in 1970. It's a small simulation of a cell population. Game of Life has no serious biological foundation. Cells live on a chessboard-like grid. Only up to one cell can live in a single space. Initially some cells must be scattered round the place. Cells will be born or will die according to the following simple rules:

If a space is populated

	Each cell with less than two neighbours dies since it feels too lonely :)
	Each cell with more than three neighbours dies because the area is overcrowded
	Otherwise the cell survives

If a space is empty

A new cell is born if it has exactly three neighbours

Even though these roules are so simple they produce a vividly floating population of dying and newly born cells. Sometimes based on an initial state populations can grow unexpectedly. After many iterations some cell configurations remain stable and there are even so called 'walkers' that constantly move into one direction simply by dying and being born.

The idea of Game of Life is well known in computer science but since I discovered it very late and found it so appealing I had to code it myself. After starting the program you can set cells with the left mouse button and start or stop Life with the right one. Enjoy the download below.

GameOfLife.zip (64 kB)
Source Code as Visual Studio Project (33 kB)

(screenshot from GameOfLife)

ops - OpenPictureSpace (Linux)

ops is an image viewer for linux based on the SDL library. Using ops you can scan your directories for images. A fullscreen thumbnail image is then displayed that can be scrolled using the cursor keys. Clicking a small image displays it in its original size. Further clicks enlarges the image even further.
Other image viewers build a n x m grid with thumbnails. In contrast ops scales images only vertically and places as many images into a line as possible. So the screen space is optimized for a maximum number of thumbnails.

ops knows to following options:

-r	recurse into subdirectories
-q #n	thumbnail quality (n=0: low/fast (default), ..., n=5: hight/slow)
-t #n	height of thumbnail in pixels (n=12, ..., 255)
-m #n	message output (n=0: quiet / n=1: verbos / n=2: debug)
-d #n	n=0: quiet / n=1: verbos / n=2: debug (quite a lot)
-s #n	screen resolution n=0: 640x480 / n=1: 800x600 / n=2: 1024x768 n=3: 1280x1024 / n=4: 1600x1200

example: ops ~/ -r -q5 (display all images in your home directory tree with best quality)

ops.zip Linux executable statically linked (763 kB)
Source Code source code - needs SDL + SDL_image devel. version (8 kB)

Please note that the latest version of ops is maintained by Marc Le Douarain. It includes some additional features like added filenames and a better background processing for large directories. I didn't yet check his add-ons for security issues so there are no guarantees from my side but his attempts to improve the application seem to be trustable.

(screenshot from ops)