Willkommen auf den Seiten der Firma Zipproth GmbH! Im Großraum München bieten wir Software-Entwicklung (C++/C#) als Dienstleistung mit folgenden Schwerpunkten an:
  • Embedded Systems
  • Konfigurationsmanagement
  • Bildverarbeitung
  • GUI-Entwicklung (Qt, WPF)
Daneben stehen auf dieser Seite einige Produkte und Informationen zur Verfügung.
The software Straton is designed to make image processing for astrophotographers easier.

For narrowband photography it's necessary to combine the color channels in some way. The state of the art procedure for this is the Tone Mapping as described by J-P Metsavainio.

The first step of Tone Mapping is to remove the stars from the image, which is a precondition for later extreme stretching of the brightness (because doing this with the stars left in the image would destroy them, as each star contains not only bright, but also dark pixels).

J-P Metsavainio's procedure to remove stars is pretty good, but tedious - you need to repeat 18 manual steps for each channel. Furthermore, you need Adobe® Photoshop®.

Straton can do this in a single click. And it does it much better. Fullstop.

Of course nothing is perfect, but using Straton you will get a starless image with a single click. After that you have powerful tools at your hands to do manual post processing - which is normally completed in about 10 minutes. Have a look at the samples - here I've done no manual post processing.

You will find lots of images processed with Straton on Straton's Astrobin page. Another sample which you can download here:

The right images are the result of Straton's fully automatic image processing (no manual post processing). Download full image data here.

Normally you will first open an image and simply click Tools-->"Remove stars from this image".

After that, you can easily compare the resulting image with the original one (even in magnification mode, simply press '1'). You can even compare with the image without nebulae (press '2').

In case you want to change anything, you can easily do that by right clicking these pixels:

  • If a star is left you may use Straton's "remove this star" function (use Alt+left click as a shortcut).
  • In case parts of nebula had been wrongly removed (which should happen far more rare) - simply do a Ctrl+left click. It's simple to verify if all nebulae are still healthy by pressing '2', which will compare with the image without nebulae.

You may even work with raw image data thanks to Straton's built in gamma slider, which is a screen transfer function that won't change the image data.

The small image in the upper right is the reference image. By default it contains the original image. You can do useful operations by right clicking it:

It is possible to modify certain parameters used for the star recognition. This is normally not necessary, but just in case they are available. For documentation hover the mouse cursor over them (see bottom right of Straton window).

All algorithms work independent from the brightness of the image - that means you can separate stars in your raw image data (the above left image is stretched only for documentation purposes). Straton is able to read and write nearly all image formats, especially those used in astrophotography (FITS and TIF gray images with 16 bit depth).

You can download a demo version here. You need Windows XP SP3 or any newer Windows OS (for example Windows 7). All functions are available except saving the image.

If you find Straton useful you may buy a full version for 15,- EUR here.

Please drop me a mail if you have any suggestions for further development. New functions will be integrated into Straton in future (Straton checks itself if there's an update).


babelscript is a script language designed to do data mining in web sites like Wikipedia for use in certain web applications. It uses a special pattern matching syntax, easy http access and automatic loop conditions. The following example prints a list of page names of all internal links on the Wikipedia main page:

load http://en.wikipedia.org as {page}
    find <a href="/wiki/{internalLink}" in {page}
    print {internalLink}

Why a new script language for this? Because with regular expressions this is much more tedious (see comparison with Python for a sample). Other features of babelscript include:
  • Automatic caching of http requests in bz2-compressed files (located in subfolder babelCache).
  • Easy definition of new commands. Just save a file with the name of the command plus extension .bls (see directory library for examples).
  • No need to define loop conditions. A loop is repeated as long as states are changing. Also, if a find command fails, the script automatically exits the loop.
  • Ready to use query command to do automated web queries using a free meta search engine, for example
    query Obama as {link}
    The query command is a babelscript module itself (located in the directory library).
This software is freeware and comes without any warranty. It is a work in progress, so if you have any feedback or questions, please mail to info (at) zipproth.de.

In the following example I add German descriptions of chess openings to a file "eco.pgn" that contains the corresponding English chess opening codes. The file eco.pgn contains the following line for each opening (for example):

[ECO "B08"]

B08 denotes the code of the chess opening. The script searches this code in the first column of an html table in Wikipedia, proceeds to the third column and extracts the German description located there. This description is then inserted into eco.pgn as a line:
[White87 "German description"]

Doing that in Python is tedios because one needs to write a needlessly complex regular expression

r'\[ECO \"(?P<code>[A-E0-9]*)\"\]'

that not only matches the line [ECO "B08"], but also makes it possible to access the three character code B08. I thought it would be great to have a syntax for this purpose that is readable and therefore  less error-prone. Obviously, this is:

 [ECO "{code}"]

The variable {code} is set to the content found in the file eco.pgn and can be accessed in subsequent commands.

babelscriptPython (incomplete source code)
load eco.pgn as {pgn}
load http://de.wikipedia.org/w/index.php?title=ECO-Codes as {wikipedia}

  find [ECO "{code}"] in {pgn} // now we are further than the whole Python code to the right

  findfirst <td>{code}</td> in {wikipedia} // find the code on the Wikipedia page
  find <td> in {wikipedia} // jump to next column
  find <td>{description}</td> in {wikipedia} // get German description
  striphtml {description} // free description from any html tags
  utf8toascii {description} // convert description to plain ASCII
  insert {newline}[White87 "{description}"] into {pgn} // insert description

save {pgn} as ECO_out.pgn
import urllib
import fileinput
import re

wikipedia = urllib.urlopen("http://de.wikipedia.org/w/index.php?title=ECO-Codes").read()
pgn = open("eco.pgn").read()

for eco in re.finditer(r'\[ECO \"(?P<code>[A-E0-9]*)\"\]', pgn):
    print eco.span('code')

This loop searches for [ECO "..."] and writes the position of the text between quotes to the tuple code. Now we need to extract the actual text, search it in the Wikipedia page, extract the corresponding German description and insert it into pgn. As we cannot change pgn in the above loop, we have to make a list of all text positions and insert the German descriptions afterwards in a second pass.

Aside from the fact that the above regular expression is unreadable, the whole task is done much simpler and in one pass in babelscript.
This is a list of commands babelscript current supports. It is possible to add arbitrary new commands, since any file "xyz.bls" will be used as a new command xyz (see below section Library commands). In general, each parameter of a command may contain variables (enclosed in curly brackets { }) or constant text or both, the examples show only the normal usage.

Native commands

  1. String processing

    In babelscript, strings are written without quotation marks and any string variables are directly inserted into these strings. The parser recognizes variables by means of curly brackets. The following special string variables may be used:

    - {newline} means a line feed character. When searching for it with find, it also matches the sequence CR-LF.
    - {tab} is a tab character.
    - {empty} is the empty string.
    - {blank} is a space character.
    - {app} is the path to the babelscript installation folder (without trailing slash)
    - {temp} is the system's temporary folder (without trailing slash)
  • find xyz in {text}
    Searches xyz in {text}, beginning from the last position. If the search fails, the program continues at the next repeat command belonging to the current loop. If there is no surounding loop, the program exits with a message. xyz may contain unbound variables, which are set to content found in {text}.
load http://en.wikipedia.org as {page}
striphtml {page}
find Welcome to {text}.{blank} in {page}
print {text} // will print "Wikipedia, the free encyclopedia that anyone can edit"
  • findfirst xyz in {text}
    Same as find, but first resets the position in {text}, so the search starts at the first character.
  • insert xyz into {text}
    Inserts the given string into the text variable. As insert position the last position is used. This may be either the position behind the last insert command or the position behind the text found in the last find / findfirst command. The initial position is the beginning of the text.
  • replace abc with def in {text}
    Replaces all occurrences of the first parameter with the second one in the given variable. The string position in {text} is unchanged.
  • add xyz to {hash}
    Adds the given string to the hash variable. This allows fast testing if a string collection contains a certain string via if...contains. or if...misses

  • let {text} xyz
    Sets the text variable to the given string.
  • striphtml {htmlpage}
    Converts a html page into plain text.
load http://en.wikipedia.org as {page}
striphtml {page}
print {page}
  • removetag <tag> from {htmlpage}
    Removes all html tags of the given form <tag> from the string variable {html}. A tag may include arguments.
load http://en.wikipedia.org as {page}
removetag script from {page}
removetag span class="mw-headline" from {page}
save {page} as wikipedia.html
  • utf8toascii {text}
    Converts a UTF-8 encoded text to plain ASCII.
load http://en.wikipedia.org as {page}
utf8toascii {page}
save {page} as wikipedia.html
  • truncate {text} to {length}
    Transform {text} into a unique hash string with {length} characters. The character set is restricted and suitable for use in URLs. If the text is not longer than {length} characters, it will be unchanged.
  1. Image processing

    • cropimage {srcImage} as {destImage}
      Removes empty borders from {srcImage} and stores the result in {destImage}.

    • scalewidth {srcImage} ato {width} as {destImage}
      Resizes {srcImage} to the given {width} and stores the result in {destImage}.

    • scaleheight {srcImage} to {height} as {destImage}
      Resizes {srcImage} to the given {height} and stores the result in {destImage}.

    • getwidth {image} as {width}
      Stores the width of the image in {width}.

    • getheight {image} as {height}
      Stores the height of the image in {height}.

    • replacecolor {image} : {from} with {to}
      Replaces all pixels in {image} with color {from} with color {to}, using a tolerance of 5 in the red, green and blue values.
  2. Flow control

  • loop
    Starts a loop; the respective repeat command jumps back to this position.
  • repeat
    Checks if during the last loop pass any variable has been changed (this check covers only variables that are used outside the loop and includes the reading position of the variables). If so, erases all variables that are introduced inside the loop and jumps back to the loop command. Otherwise the loop is exited.
load http://en.wikipedia.org as {page}
    find <a href="/wiki/{internalLink}" in {page}
    print {internalLink} // prints a list of page names of all internal links on the wikipedia main page
  • if {variable} contains xyz
    The commands until the corresponding endif will only be executed if the text abc contains xyz. Both parameters may contains variables. {variable} may be both a string or a hash (see add command).
  • if {variable} misses xyz
    The commands until the corresponding endif will only be executed if the text abc does not contain xyz. Both parameters may contains variables. {variable} may be both a string or a hash (see add command).
  • if {variable} == xyz
    The commands until the corresponding endif will only be executed if the text in {variable} is equal to xyz. Both parameters may contains variables.
  • if {variable} != xyz
    The commands until the corresponding endif will only be executed if the text in {variable} is different from xyz. Both parameters may contains variables.
  • if {variable} > xyz
    The commands until the corresponding endif will only be executed if the text in {variable} is greater than xyz. If both parameters can be interpreted as numbers, a number comparison is made, otherwise a string comparison. Both parameters may contains variables.
  • if {variable} < xyz
    The commands until the corresponding endif will only be executed if the text in {variable} is smaller than xyz. If both parameters can be interpreted as numbers, a number comparison is made, otherwise a string comparison. Both parameters may contains variables.

  • else
    May be used inside an if / endif statement. The code between else and endif will be executed if the if-condition is false.
  • pause
    Pauses the script until the user press the return key.
  • quit
    Exits the script.
  1. I/O

  • load filename.ext as {text}
    Loads contents of the file filename.ext into the variable {text}. The file may be in the local file system or in the internet. In case of a HTTP request, it will be repeated if it fails. The file name may contain variables.

  • reload filename.ext as {text}
    Same as load, but will not use babelscript's internet cache.
  • save {text} as filename.ext
    Saves the string {text} into the file filename.ext. If {text} contains an image stream (e.g. jpg) and the file extension is an image file extension (e. g. bmp), {text} is saved as an image. The file name may also be a variable.
  • append {text} to filename.ext
    Same as save, but {text} is appended to the file. If the file does not exist, it is created.
  • delete filename.ext
    Deletes the file.
  • print text
    Prints the argument to the command line. All variables are replaced with their content. If the argument is left out, a blank line is printed. As a shortcut for print, a question mark may be used.
  • open xyz with parameters
    Opens the argument in either browser or text editor. Any parameters are optional. If the argument is a link, not the link itself but its target will be opened.
open http://www.google.com // opens web site in the browser
open test.jpg // opens image test.jpg in the associated image viewer
open {variable} // opens the content of {variable}. If {variable} begins with http:// or file:///, the link target will be opened.
open C:\windows\regedit.exe with /e {temp}\startup.txt HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run // list Windows startup entries
  1. Arithmetic

    • calc {result} = {num1} + {num2} - Add {num1} and {num2}, store the result in {result}.
    • calc {result} = {num1} - {num2} - Subtract {num2} from {num1}and store the result in {result}.
    • calc {result} = {num1} * {num2} - Multiply {num1} with {num2} and store the result in {result}.
    • calc {result} = {num1} / {num2} - Add {num1} and {num2}, store the result in {result}.
    • calc {result} = {num1} ^ {num2} - Raise {num1} to the power of {num2} and store the result in {result}.
    • round {num1} to {num2} Round {num1} to {num2} decimal places.
    • hex {result} = {num} - Convert  {num} to hexadecimal representation, using groups of two digits, and store the result in {result}.
    • interpolate {b} as {result} with {a} .. {c} ==> {va} .. {vc} - Interpolate the value of f(b) with f(a)=va, f(c)=vc and store the result in {result}.

Library commands

If a script contains an unknown command, first the current directory is searched for scripts with the name of the command plus extension ".bls". Afterwards the directory library in the babelscript application folder is searched. If a script is found, it will be called.

Inside a user-defined command script two special variables may be used:
  • {arg1} This variable is automatically set to the first parameter of the command in the calling script.
  • {result} This is automatically replaced with the second parameter of  the command in the calling script.
The calling script must use the keyword as to seperate two parameters. Alternatively library commands with one parameter or no parameters are allowed. The following command scripts are part of the current distribution:
  • query {text} as {link}
    Queries a free meta search engine for {text} and sets {link} to the first link on the result page.
  • help
    Shows this page in the browser (local copy).


Bitte geben Sie Stichworte oder eine Frage ein:

Technische Informationen

Das Bilddaten-Kompressionsverfahren jetpix wurde 1999 entwickelt und erreicht eine auch nach heutigem Stand der Technik extrem hohe Datenreduktion von Bildern bei hoher Bildqualität (bei großen Auflösungen etwa um Faktor 5 kleinere Bilddateien im Vergleich zu jpeg). Es fand unter anderem Verwendung in der Bilddatenbank der Münchner vividia AG sowie in einem Fernsehprojekt, um Pressefotos bei beschränkter Bandbreite effizient zugänglich zu machen.

Das Verfahren schnitt in einem Wettbewerb der Zeitschrift c't vor allem hinsichtlich der Performance ausgezeichnet ab. Die anderen Teilnehmer waren:

  • Uni Rostock
  • FHTW/ Telekom BERKOM
  • Luratech
  • Image&Video Compr.
  • Uni Potsdam
  • MeVis/CeVis, Uni Bremen

Bisher erschienen folgende Artikel in der Zeitschrift Computer, Schach & Spiele, die seit 1983 für Anwender und Programmierer von Schach-Software erscheint. Die Zeitschrift hatte auch internationale Mitarbeiter wie Ken Thompson.

Wer den Schriftsteller Robert A. Heinlein (noch) nicht kennt, hier ein paar Fakten über ihn, ganz dem Motto einer seiner Romanfiguren:
What are the facts? Again and again and again — what are the facts? Shun wishful thinking, ignore divine revelation, forget what "the stars foretell," avoid opinion, care not what the neighbors think, never mind the unguessable "verdict of history" — what are the facts, and to how many decimal places? You pilot always into an unknown future; facts are your single clue. Get the facts!
  • In seinem Buch The Moon Is a Harsh Mistress (1966) spielt eine tragende Rolle ein Computer, der Bewusstsein erlangt. Dieser wird auch aus technischer Sicht sehr ausführlich beschrieben.
  • Mit seiner Kurzgeschichte Waldo erfand er 1940 die gleichnamigen Roboter-Greifarme (engl. Waldos), wie sie heute in der Industrie eingesetzt werden.
  • In seiner Novelle Gulf beschreibt er die Kunstsprache "Speedtalk", welche durch effizientere Grammatik entsprechend auch das Denkvermögen beschleunigen soll. Diese Idee gründet sich auf die General semantics des Linguisten Alfred Korzybski (1879-1950), welche von bekannten Wissenschaftlern wie Douglas Engelbart (Erfinder der Computer-Maus) aufgegriffen wurde.
  • Mit seinem Roman Beyond this Horizon erfand er 1942 das Wasserbett. Ein Patentierungsversuch 1986 von Charles Hall wurde deswegen abgelehnt.
  • Der Mondkrater Heinlein ist nach ihm benannt. In diesem Krater wird Wassereis vermutet.
  • 1969 kommentierte er an der Seite des bekannten CBS-Journalisten Walter Cronkite die erste bemannte Mondlandung.
  • Er erhielt posthum die NASA Distinguished Public Service Medal. Auf der Website der NASA wird er über 200 Mal erwähnt.
Mehr Informationen über den Autor: Heinlein Society
Bücher: Amazon-Liste
Shortest Rubik's Cube move sequences


This is the list of Rubik's cube move sequences which I use to solve it. The sequences are optimized for easy memorization, so the system is not very fast (using it, you can solve the cube in about 90 seconds), but contains relatively few moves. If you know all of these Sequences, it is possible to solve the cube in about 2 minutes.

At the 2008 competition in Osaka a new world record was established to solve the cube in an average time of 11.33 seconds. The average optimum solve sequence length is 18 moves. Rubik's cube can reach 4 * 1019 different states, so any effort to solve the cube with random moves is doomed to failure, since one can try for 600 billion years doing random moves twice a second and still may not solve the cube.

Solving the top layer

The system makes use of the classical layer approach, so first solve the top layer. Solve its edge cubes so that the side colors match their middle corners, with this result:

Now solve the corners of the top layer. The easiest way to move a corner from the buttom to the top layer is turning the buttom layer so that the corner is directly under the position where it belongs:

 Then (1) turn the side that contains the corner stone, (2) move the corner stone into its place and (3) turn the side back. You always have to turn that side where the corner cube shows the top color (in this example the front side, because there the corner shows the top color blue):
If the top color is facing downwards, you first have to rotate the corner cube - you can do that with a similar move sequence, just do the second (buttom) move twice. Obviously, if a corner cube is already in the first layer, but wrongly placed, you have to move it into the buttom layer with the same move sequence and then continue.
Now the corner stone has arrived in the top layer:

You must only solve three corners, because you need the last unsolved corner to be able to solve the second layer easily.

First three edges of middle layer
(always place unsolved edge next to the unsolved top layer corner)

Find a buttom layer edge that belongs to the middle layer and then turn the top layer so that the unsolved corner is placed directly over the target position of that buttom layer edge:

After that preparation, turn the whole cube so that the top layer is on the left side and turn the bottom (now right side) layer so that your situation matches either 1a or 1b. Then move the edge to its target position by either sequence 1a or 1b.

Repeat that for three of the four middle layer edges and then solve the last top layer corner as shown in section "Solving the first layer". Before doing that, make sure that the corner is placed directly over the remaining unsolved middle layer edge. When you solved the corner, continue with 2a/b.

Sequence 1a
Top layer facing left.
Sequence 1b
 Top layer facing left.

Last edge of middle layer
(first solve the remaining top layer corner)

Sequence 2a
Top layer to the top again, image shows the buttom layer. Moves an edge cube from the buttom layer to the middle one.
Sequence 2b
Moves an edge cube from the buttom layer to the middle one.

Buttom layer edge orientation
(ignore edge placement, this is done later)

Sequence 3a
Buttom layer faces top side (as in the rest of buttom layer sequences). Flips the upper front and the upper back edge.
Note: If all edges are flipped, then the sequence has a different effect, that is the one shown in 3b.
Sequence 3b
Flips the upper front and the upper right edge.
Note: If all edges are flipped, then the sequence has a different effect, that is the one shown in 3a.

Buttom layer corner orientation
(ignore corner placement, this is done in the next step)

Sequence 4a
Rotates three corners clockwise. If all corners or only two are wrong, then rotate the corners so that three corners are wrong (always possible in one step).
Sequence 4b
Rotates three corners counter-clockwise. If all corners or only two are wrong, then rotate the corners so that three corners are wrong (always possible in one step).

Buttom layer corner placement
(prepare step necessary: turn the whole cube so that the front side faces up)

Sequence 5
In both cases this sequence can be used. As a preparation, you have to rotate the whole cube so that the front side faces up.

(only for second case)

Buttom layer edge placement

Sequence 6a
Cycles three upper edges clockwise.
Sequence 6b
Cycles three upper edges counter-clockwise.