Snow-Apple provides an icon pack for Gnome.

Mark Finlay fairly converted the nautilus 2.0.x theme called Snow-Apple, to an icon theme for gnome 2.2.x. thanks to him.

Snow Path Formation Simulator is a program that models the process of people forming very distinct, and yet not always altogether logical looking, paths in the snow as they walk across open spaces.

The evolving condition of the snow is displayed graphically. This project may eventually mature into a screensaver.

PlanetPenguin Racer is an FREE OpenGL racing game featuring Tux, the Linux mascot.

The goal of the game is to slide down a snow- and ice-covered mountain as quickly as possible. It is based on the GPL version of TuxRacer.

Flickr-karamba will automatically download pictures from Flickr.com and show them on your Desktop. They are filtered with tags(you can search for serveral tags, sepperated by comma [beach, snow]).

In this early version, you can only see public photos. Oh, and please be aware: python+flickr api=slooow performance...

Requires:
- Python Imaging Library

flickr-karamba uses flickr.py

And now enjoy my first superkaramba theme, and feel free to post bugs/comments.

Tornado project is a clone of the original C64 game.

The goal of the game is to destroy the opponents house with certain weather phenomena: rain, snow, hail, lightning, and the tornado.

The game can be played together (two players), against the computer (or two computer players against each other) or over a TCP connection.

Tux Racer is a very fun arcade game for Linux.

The main goal in Tux Racer is to have fun! Race down mountainous terrain as quickly as possible, while collecting herring to increase your score!

Here are some key features of "Tux Racer":

· Fun, easy to learn
· Exciting 3D courses
· Sophisticated physics result in thrilling rides down the mountains
· Collect herring while avoiding obstacles for high scores
· Race over a variety of surfaces, including fluffy snow and slick ice
· Race in various weather conditions and lighting conditions
· Create your own courses using any paint program such as The GIMP (no 3D modeller required)
· Suitable for all ages.

Visual difference metrics can predict whether differences between two images are visible to the human observer or not. Such metrics are used for testing either visibility of information (whether we can see important visual information) or visibility of noise (to make sure we do not see any distortions in images, e.g. due to lossy compression).

The image below shows how two input images, a reference image (upper left) and a distorted image (lower left), are processed with the VDP to produce a probability of detection map (right). Such probability of detection map tells how likely we will notice a difference between two images for each part of an image.

Red color denotes high probability, green - low probability. Red color is mostly present in the areas where there is a snow covered path. Because of smooth texture of the snow, there is not much visual masking and distortions are easily visible.

Although there are dozens of visible difference metrics that serve a similar purpose, our Visual Difference Predictor for HDR images (HDR-VDP) has two unique advantages: firstly, our metric works with a full range of luminance values that can be meet in a real word (HDR images), and secondly, we offer a complete source code for free.

High Dynamic Range Visible Difference Predictor (HDR-VDP) can work within the complete range of luminance the human eye can see. An input to our metric is a high dynamic range (HDR) image, or an ordinary 8-bits-per-color image, converted to the actual luminance values. The proposed metric takes into account the aspects of high contrast vision, like scattering of the light in the optics (OTF), nonlinear response to light for the full range of luminance, and local adaptation.

Persistent::LDAP is a persistent class implemented using a LDAP directory.

SYNOPSIS

use Persistent::LDAP;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $person =
new Persistent::LDAP(localhost, 389,
cn=Directory Manager, test1234,
ou=Engineering,o=Big Snow Org,c=US);

### declare attributes of the object ###
$person->add_attribute(uid, ID, String);
$person->add_attribute(userpassword, Persistent, String);
$person->add_attribute(objectclass, Persistent, String);
$person->add_attribute(givenname, Persistent, String);
$person->add_attribute(sn, Persistent, String);
$person->add_attribute(cn, Persistent, String);
$person->add_attribute(mail, Persistent, String);
$person->add_attribute(telephonenumber, Persistent, String);

### query the datastore for some objects ###
$person->restore_where(& (objectclass=person)(mail=*bigsnow.org),
sn, givenname);
while ($person->restore_next()) {
printf("name = %s, email = %sn",
$person->givenname . . $person->sn,
$person->mail);
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a LDAP directory to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Chart::EPS_graph creates line graphs in PostScript as *.eps format.

SYNOPSIS

# Create anew a 600 x 600 points (not pixels!) EPS file
my $eps = Chart::EPS_graph->new(600, 600);

# Choose minimum required display info
$eps->set(
label_top => Graph Main Title,
label_y1 => Y1 Axis Measure (Units),
label_y2 => Y2 Axis Measure (Units),
label_x => X Axis Measure (Units),
);

# Choose 6 of 13 named chans, 4 at left, 2 at right
$eps->set(
names => @all_13_name_strings,
data => @all_13_data_arefs,
y1 => [7, 8, 10, 11],
y2 => [9, 12],
);


# Choose optional graph features
$eps->set(
label_y1_2 => Extra Y1 Axis Info,
label_y2_2 => Extra Y2 Axis Info,
label_x_2 => Extra X Axis Info,

# Any common browser color no matter how hideous.
bg_color => DarkOliveGreen,
fg_color => HotPink,
web_colors => [Crimson, Lime, Indigo, Gold, Snow, Aqua],

# Any known I font no matter how illegible
font_name => ZapfChancery-MediumItalic,
font_size => 18,

# See POD about this one. But in brief:
# If set to "1" channel innumeration gaps will be closed.
# If set to "0" (the default) they will be left as they are.
close_gap => 0,

# If the 0th channel is not for the X axis (the default) then the
# data point count is used as the X axis, which you may scale.
# So if X were Time in seconds, with no 0th channel having acutally
# recorded it, but each data point were known to be 0.5 seconds...
$self->{x_is_zeroth} = 0; # Boolean, so 1 or 0.
$self->{x_scale} = 2; # Have 10th datapoint show as 20, etc.
);

# Write output as EPS
$eps->write_eps( cwd() . /whatever.eps ); # Write to a file.

# View, convert or edit the EPS output
$eps->display(); # Display in viewer (autodetects gv or gsview.exe).
$eps->display(GS); # Convert to PNG via Ghostscript.
$eps->display(GIMP); # Open for editng in The GIMP.

Glest is a project for making a free 3D real-time customizable strategy game.

Current version is fully playable, includes single player game against CPU controlled players, two factions with their corresponding tech trees, units, buildings and some maps.

Here are some key features of "Glest":

Customize every aspect of the game

· Custom units can be defined using XML files. Its posible to define its basic parameters (hp, mp, armor, sight, requirements and much more), its skills and commands and the 3d models associated with them.
· Custom upgrades can be defined. Its posibble to define how and what units they affect, its requirements and more.
· Custom factions can be defined by grouping a set of units and upgrades.
· Custom resources can be defined.
· Custom tech-trees can be defined by grouping a set of factions and resources.
· Custom tilesets can be defined. Its posible to define the surface textures, object 3d models (such as trees os rocks), ambient sounds and more.
· Maps can be edited with the glest map editor.

Graphics: OpenGL 1.3 graphics

· Heightmap terrain.
· Free camera movement (translation, rotation and zoom).
· Own 3d format that can be exported from 3dsmax using the g3d export plugin.
· Real-time shadows, projected or shadow mapped.
· Keyframe animated 3d models.
· Particle systems for rain, snow, fire and spells.
· Classical 3d effects: transparency, lighting, fog etc...

A.I.: ARTIFICIAL INTELIGENCY

· A* based pathfinding algorithm.
· Basic AI for computer controlled players.

Whats New in This Release:

· New Magic units:Tower of Souls, Golem, Daemon giant, Drake rider
· New Tech units:Aerodrome, Air ballista, Rider, Ornithopter, Airship
· New Magic upgrades
· New Tech upgrades
· New animations for existing units
· Shared vision between allies
· New particle blending
· Players now start on the location indicated in the game settings menu
· Score system
· HTML documentation
· Increased projectile accuracy
· Optimized particle rendering
· Loads of balance changes

Imager::Color is a Perl module with color handling for Imager.

SYNOPSIS

$color = Imager::Color->new($red, $green, $blue);
$color = Imager::Color->new($red, $green, $blue, $alpha);
$color = Imager::Color->new("#C0C0FF"); # html color specification

$color->set($red, $green, $blue);
$color->set($red, $green, $blue, $alpha);
$color->set("#C0C0FF"); # html color specification

($red, $green, $blue, $alpha) = $color->rgba();
@hsv = $color->hsv(); # not implemented but proposed

$color->info();

if ($color->equals(other=>$other_color)) {
...
}

This module handles creating color objects used by imager. The idea is that in the future this module will be able to handle colorspace calculations as well.

new

This creates a color object to pass to functions that need a color argument.

set

This changes an already defined color. Note that this does not affect any places where the color has been used previously.

rgba

This returns the rgba code of the color the object contains.

info

Calling info merely dumps the relevant colorcode to the log.

equals(other=>$other_color)
equals(other=>$other_color, ignore_alpha=>1)

Compares $self and color $other_color returning true if the color components are the same.

Compares all four channels unless ignore_alpha is set. If ignore_alpha is set only the first three channels are compared.

You can specify colors in several different ways, you can just supply simple values:
simple numeric parameters - if you supply 3 or 4 numeric arguments, you get a color made up of those RGB (and possibly A) components.

a six hex digit web color, either RRGGBB or #RRGGBB
an eight hex digit web color, either RRGGBBAA or #RRGGBBAA.
a 3 hex digit web color, #RGB - a value of F becomes 255.
a color name, from whichever of the gimp Named_Colors file or X rgb.txt is found first. The same as using the name keyword.

You can supply named parameters:

red, green and blue, optionally shortened to r, g and b. The color components in the range 0 to 255.

# all of the following are equivalent
my $c1 = Imager::Color->new(red=>100, blue=>255, green=>0);
my $c2 = Imager::Color->new(r=>100, b=>255, g=>0);
my $c3 = Imager::Color->new(r=>100, blue=>255, g=>0);
hue, saturation and value, optionally shortened to h, s and v, to specify a HSV color. 0 new(hue=>120, value=>1, saturation=>0.5);
web, which can specify a 6 or 3 hex digit web color, in any of the forms #RRGGBB, #RGB, RRGGBB or RGB.
my $c1 = Imager::Color->new(web=>#FFC0C0); # pale red
gray or grey which specifies a single channel, from 0 to 255.
# exactly the same
my $c1 = Imager::Color->new(gray=>128);
my $c1 = Imager::Color->new(grey=>128);
rgb which takes a 3 member arrayref, containing each of the red, green and blue values.
# the same
my $c1 = Imager::Color->new(rgb=>[255, 100, 0]);
my $c1 = Imager::Color->new(r=>255, g=>100, b=>0);
hsv which takes a 3 member arrayref, containting each of hue, saturation and value.
# the same
my $c1 = Imager::Color->new(hsv=>[120, 0.5, 1]);
my $c1 = Imager::Color->new(hue=>120, v=>1, s=>0.5);

gimp which specifies a color from a GIMP palette file. You can specify the filename of the palette file with the palette parameter, or let Imager::Color look in various places, typically "$HOME/gimp-1.x/palettes/Named_Colors" with and without the version number, and in /usr/share/gimp/palettes/. The palette file must have color names.

my $c1 = Imager::Color->new(gimp=>snow);
my $c1 = Imager::Color->new(gimp=>snow, palette=>testimg/test_gimp_pal);

xname which specifies a color from an X11 rgb.txt file. You can specify the filename of the rgb.txt file with the palette parameter, or let Imager::Color look in various places, typically /usr/lib/X11/rgb.txt.

my $c1 = Imager::Color->new(xname=>blue) # usually RGB(0, 0, 255)

builtin which specifies a color from the built-in color table in Imager::Color::Table. The colors in this module are the same as the default X11 rgb.txt file.

my $c1 = Imager::Color->new(builtin=>black) # always RGB(0, 0, 0)

name which specifies a name from either a GIMP palette, an X rgb.txt file or the built-in color table, whichever is found first.

channel0, channel1, etc, each of which specifies a single channel. These can be abbreviated to c0, c1 etc.

channels which takes an arrayref of the channel values.

Optionally you can add an alpha channel to a color with the alpha or a parameter.

These color specifications can be used for both constructing new colors with the new() method and modifying existing colors with the set() method.

Root-Portal is a GNOME program that monitors files, processes etc and displays changes either directly to the desktop or in a transparent border-less window. This is useful for monitoring system logs and for providing feedback on system activities.

Root Portal is a way to do stuff on your desktop in the background. We find it useful as a monitor of system log files such as /var/log/messages and /var/log/xferlog and /var/log/httpd/access_log etc etc.

You can have as many spots, or portals of text on the screen as you want in varying size and varying font and colour and practically any other property you care to think of. They can have the added advantage of being transcient so that you can still see your background picture underneith the text.

As well as this, using the roottext module, you can run programs such as xsnow and the snow flakes will not disappear because of the text, they will pass through it. Using the module such as gnometext allows you to shade the background and put alternate images as backgrounds for your portals.

You may also shade these custom backgrounds, the only disadvantage to this system is that programs such as xsnow cannot mix their graphics with this and disappear behind them. The only other difference between the two is that the root text can handle non-fixed sized fonts with a breeze.

Because the gnome module is using zvt, it currently does no like non-fixed sized fonts too much at all. We are hoping the author of zvt will change this in later releases of his library. As well as the file tailing facility to monitor log files, there is also a loading monitor, to show you when a new process has been created and when a process has been destroyed.
Basically this is a pretty anti-paranoia program for people who sit at their desktops and wonder who is doing what to them from the outside, what is running what on their system, and why their harddisk is suddenly ticking over for no reason *aha, crond is doing something weird*

Kraptor is a classic shoot em up scroller game, where you must fight against tons of bad dudes.

The game offers high speed action, with massive destruction and lots of fun. Kraptor features a powerful engine for 2D shooter scroller games. Massive destruction, powerful weapons, all that you always wanted in this kind of games! It is also multi-platform (DOS, Win32, Linux and more!)

Here are some key features of "Kraptor":

· FULL SOURCE CODE AVAILABLE FREE (Under MIT license)
· Works on many platforms, including DOS, Windows and Linux!
· Supports all resolutions, like 320x200, 640x480, 1024x768, etc.; even those bizarre ones, like 160x120, 320x400, etc.
· Uses stereo positional sound (you hear the ships flying around you)
· Has a incredible particle system, that let all sorts of particle effects in the explosions, fire on the ground, the ships going down in flames,and the weapons can let a trail of smoke, beams, etc
· Has a dynamic fire, smoke and explosions system based on layers and on-fly rendering, that let show a massive destruction effect on the air and ground.
· Has a dynamic enviroment sub-engine to render rain, snow, etc.
· The ships explodes into pieces, and the builds on the ground blows up in a chain-explosion effect.
· Enemys of any size, and custom IAs and weapons.
· All kind of animated bad dudes, from tiny ones to big bad bosses.
· All the flying objects cast shadows over the background, with perspective correction.
· Support for animations and cinematic, with sound and subtitles.
· A on-fly translation system with UNICODE and UTF-8 support, that can translate on the fly all the GUIs to other language.
· Multiple weapons for player and enemies.
· Has original music sound-track.
· You can lower/raise the detail level, in low detail, the game runs good even on a 486 DX2!
· Original story, with cool movies.
· Realistic huge hi-res backgrounds levels.
· Original high quality stereo sounds and music
· Support for Spanish and English translation on-fly
· Black market shop to buy new weapons, upgrade ship, etc.
· GUI driven interface like the one used in Unre*l.
· You can Save / Load your game

ogg2mp3 takes a list of OGG Vorbis formatted files and converts them to mp3 format. ogg2mp3 project is useful when you want to transfer OGG encoded files to a device which doesnt support the format (e.g. an iPod).

Each file specified on the command line is converted to a file with the same name except the ``.ogg at the end is replaced with ``.mp3. The new file is created in the current working directory unless otherwise specified with the --output-directory option.

By default, ogg2mp3 prints one line of output per file processed (printing it as the processing of that file starts) as follows:

processing 1 / 10 : 01_big_exit.ogg -> ./01_big_exit.mp3

Where 01_big_exit.ogg is the first of ten files to be processed (1 / 10), and the output file is called ./01_big_exit.mp3.

This behaviour can be modified using the --quiet and --verbose options.

OPTIONS:

Note that all command line options may be abbreviated to the shortest unique version, e.g. --output-directory can be shortened to -o because there are no other options beginning with -o. However, to see the version, at least --vers is required since there is also the --verbose option, thus ``vers is the shortest unique abbreviation of ``version.

--debug n

Set the debugging level to n. Ranges from 0 to 10, 10 being really verbose, 0 being just warnings (the default).

--id3-tags or --noid3-tags

Specify that you want (or not) ID3 tags to be copied into the MP3 file.

--force-overwrite

If an output .mp3 file already exists, overewrite it without prompting (the default is to skip such files and issue a warning).

--help

Show a brief command line help message and exit.

--output-directory dir

Tell ogg2mp3 to create the .mp3 files in the directorry dir instead of the current directory.

--prefix prefix

Prefix all output filenames with prefix.

--quiet

Dont print output unless there is an error.

--suffix suffix

Append suffix to all output filenames just before the .mp3 extension.

--verbose

If --quiet is not spcified, this switch increases the amount of information displayed as each file is processed. The extra information details the ID3 tags found in the source file.

--version

Print the program name and version and exit.

EXAMPLES:

Example 1

$ ogg2mp3 echo.ogg got_two_legs.ogg pripple_ipple.ogg
processing 1 / 3 : echo.ogg -> ./echo.mp3
processing 2 / 3 : got_two_legs.ogg -> ./got_two_legs.mp3
processing 3 / 3 : pripple_ipple.ogg -> ./pripple_ipple.mp3
This command will create three new files: echo.mp3, got_two_legs.mp3, and pripple_ipple.mp3 in mp3 format in the current directory.

Example 2

$ ogg2mp3 -o /media/ipod my_song.ogg
processing 1 / 1 : my_song.ogg -> /media/ipod/my_song.mp3
This command creates the file my_song.mp3 in the directory /media/ipod.

Example 3

$ ls *.ogg
track_01.ogg track_02.ogg track_03.ogg
$ ogg2mp3 -o /tmp --verbose *.ogg
processing 1 / 3 : track_01.ogg -> /tmp/track_01.mp3
ID3 Tags:
album => Frengers
artist => Mew
date => 2003
genre => Pop
title => Am I Wry? No
tracknumber => 1

processing 2 / 3 : track_02.ogg -> /tmp/track_02.mp3
ID3 Tags:
album => Frengers
artist => Mew
date => 2003
genre => Pop
title => 156
tracknumber => 2

processing 3 / 3 : track_03.ogg -> /tmp/track_03.mp3
ID3 Tags:
album => Frengers
artist => Mew
date => 2003
genre => Pop
title => Snow Brigade
tracknumber => 3

As you can see, adding the --verbose option turns on display of ID3 tags.

blueMarine project is about an open source workflow for digital photography.

What does it mean?

Start thinking of an opensource application like Aperture or Lightroom that enables you to organize, develop, print and publish your photos. Pretty standard stuff nowadays. Opensource, at first sight, means that the application is free. Now think of an application written with the JavaTM language: the application runs everywhere, Mac OS X, Linux, Windows. Now think of a community of people that adds code, plugins, crazy ideas, integrating some of the latest, cool technologies around, such as GPS positioning or geo-mapping.

Well, this is just the core concept of the blueMarine project.

Lets go on and lets think of the workflow. For the existing commercial applications the workflow starts just after shooting the photo and ends with a print on paper, the photo archived and maybe a web gallery published.

Just for a starter, we could do these things in innovative ways. For instance, trip reports could take advantage of GPS positioning data and Google Maps. Galleries could be presented in form of a virtual 3d gallery with walls and pictures hang on them.

Thinking of it twice, there are holes in workflows supported by current commercial applications. For instance, if you want to filter your images with a sophisticated noise reduction algorithm or if you want to create a bigger composite photo out of several shots, you likely have to use an external application. Some communities, such as amateur astrophotographers, need some very special processing that is usually performed by means of specific software. Wouldnt be better to have all of these facilities integrated in a single front end?

Now, lets broaden our workflow horizon. It can extend well beyond the print or the archival. For instance, an ornithologist usually manages field notes about the bird observed and photographed: directly binding them to photos and maybe GPS positioning data is much better than keeping a separate Excel sheet. It can also start much before shooting the photo. Think of trip planning: maybe you travel to nice places and spot interesting subjects, but not all the conditions are favorable: the weather, the light, the sun position, or the season (snow, blossomed flowers, foliage colors). Maybe you take some photos but at home you decide: hey, Im going to return there next Fall when the trees are reddish. Wouldnt be cool if a software application could allow you to easily manage all of these wanna-shoot-again photos, maybe providing assistance to guess which will be the sun position in a certain day and hour and integrating weather forecasts? And synthetising a trip program that can be uploaded on your palm gear?

Theres a further point with opensource photo workflow. Its related to the world of camera raw formats, that is the way professional DSLR cameras work. They provide you with the raw bits from the sensor that need to be extensively cooked, or developed, for getting a good image. This approach gives a tremendous amount of control to the photographers - too bad that most formats are proprietary and not documented. blueMarine supports the OpenRAW initiative and provide an opensource implementation of developing tools for camera raw formats from an ever increasing number of vendors.

Well, all of this and more is the aim of the blueMarine project.