Free graphics card comparison software for linux

Kernel Configuration Comparison (kccmp) provides a GUI for comparing two Linux kernel ".config" files.
It shows configuration variables with different values in a tabular format. It also shows configuration variables found in only one of the input configuration files.
Building:
kccmp by default requires Qt 3.x. However, by changing one line in kccmp.pro you can build against Qt 4.x. Note that the Qt 4.x build requilres libboost_regex as well.
The standard build is as easy as:
example:
% qmake
% make
Usage
% kccmp /path/to/first/.config path/to/second/.config
example:
% kccmp /usr/src/linux/.config /usr/src/linux/.config.old
Enhancements:
- This release was ported to Qt 3.x.
- The requirement for libboost_regex was removed.
- Building with either Qt 4.x or Qt 3.x is now supported.

Gd is a graphics library. It allows your code to quickly draw images complete with lines, arcs, text, multiple colors, cut and paste from other images, and flood fills, and write out the result as a PNG or JPEG file. This is particularly useful in World Wide Web applications, where PNG and JPEG are two of the formats accepted for inline images by most browsers.

In gd 1.0, it stood for "gif draw." After the Unisys patent on the LZW compression used in GIF came to light and GIF support was dropped, it did not officially stand for anything, but lets just say "graphics draw" and leave it at that. (GIF support is back, thanks to the expiration of the patent, but gd can draw much more than GIFs.)

This is a quick install guide:

1. Type ./configure
2. Type make install

PHP Greeting card class can be used to compose and send greeting cards by email.

PHP Greeting card class can compose and send an email message with a greeting either in text, in HTML with an image, or in HTML with Flash content.

The HTML version of the card may include a greeting picture.

Graphics::ColorUtils Perl module is an easy-to-use color space conversions and more.

SYNOPSIS

use Graphics::ColorUtils;

( $y, $i, $q ) = rgb2yiq( $r, $g, $b );
( $r, $g, $b ) = yiq2rgb( $y, $i, $q );
$hex_string = yiq2rgb( $y, $i, $q );

( $c, $m, $y ) = rgb2cmy( $r, $g, $b );
( $r, $g, $b ) = cmy2rgb( $c, $m, $y );
$hex_string = cmy2rgb( $c, $m, $y );

( $h, $l, $s ) = rgb2hls( $r, $g, $b );
( $r, $g, $b ) = hls2rgb( $h, $l, $s );
$hex_string = hls2rgb( $h, $l, $s );

( $h, $s, $v ) = rgb2hsv( $r, $g, $b );
( $r, $g, $b ) = hsv2rgb( $h, $s, $v );
$hex_string = hsv2rgb( $h, $s, $v );

# -----

use Graphics::ColorUtils qw( :gradients );

( $r, $g, $b ) = grad2rgb( $name, $f ); # where 0.0 colorAllocate( hsv2rgb( 270, 0.5, 0.3 ) );.)

Features:

Color Space Conversions
Color space conversions, in particular between the "intuitive" color spaces HSV (Hue/Saturation/Value) and HLS (Hue/Lightness/Saturation) to and from RGB (Red/Green/Blue).
Color Lookup
Color lookup by name for three standard sets of colors: WWW/CSS, SVG, and X11.
Color Gradients
Management of color gradients, which can be indexed by a floating point number in the range 0..1. (Mostly intended for false-color data visualization.)

Graphics::ColorPicker is a Perl module for WYSIWYG web applications that allow selection of HEX color numbers.

SYNOPSIS

use Graphics::ColorPicker;
or
require Graphics::ColorPicker;

make_page($path_to_images);
send_page($html_txt,$type);
$time_string = http_date($time);
$name = script_name;
$html_text=frames($websafe);
$html_text = msie_frame;
$html_text=picker($darkimg,$liteimg,$size,$bsize,greyimg);
$html_text=no_picker;
$html_text=cp216_ds($clrdot,$border,$square)
$javascript_text = jslib;
$html=make_buttons(%look_n_feel,$url,$active,@buttons,$xtra);
$html_text=pluck($color);

Graphics::ColorObject can convert between color spaces.

SYNOPSIS

use Graphics::ColorObject;

# rgb to hsv
$color = Graphics::ColorObject->new_RGB([$r, $g, $b]);
($h, $s, $v) = @{ $color->as_HSV() };

# one rgb space to another (NTSC to PAL)
$color = Graphics::ColorObject->new_RGB([$r, $g, $b], space=>NTSC);
($r, $g, $b) = @{ $color->as_RGB(space=>PAL) };

ABSTRACT

Use this module to convert between all the common color spaces. As a pure Perl module, it is not very fast, and so it you want to convert entire images quickly, this is probably not what you want. The emphasis is on completeness and accurate conversion.
Supported color spaces are: RGB (including sRGB, Apple, Adobe, CIE Rec 601, CIE Rec 709, CIE ITU, and about a dozen other RGB spaces), CMY, CMYK, HSL, HSV, XYZ, xyY, Lab, LCHab, Luv, LCHuv, YPbPr, YCbCr, YUV, YIQ, PhotoYCC.
Conversion between different RGB working spaces, and between different white-points, is fully supported.

For any supported color space XXX, there is one constructor new_XXX that creates a color using data in that color space, and one method as_XXX that returns the current color as expressed in that color space. For example, for RGB there is new_RGB and as_RGB. The color data is always passed as an array reference to a three-element array (four-element in the case of CMYK). Thus, to convert from RGB to HSL, you can use:

$color = Graphics::ColorObject->new_RGB([$r, $g, $b]);
($h, $s, $l) = @{ $color->as_HSL() };

The constructor can always take a hash of optional arguments in addition to the color value, namely the working RGB space and the white point. For example:

$color = Graphics::ColorObject->new_RGB([$r, $g, $b], space=>Adobe, white_point=>D65);

For a list of all supported color spaces, call Graphics::ColorObject->list_colorspaces(). For a list of all RGB working spaces and of all white points that this module supports, call Graphics::ColorObject->list_rgb_spaces() and Graphics::ColorObject->list_white_points().
If not specified, the working RGB space will be sRGB. Many non-RGB conversions also rely on an implicit RGB space, and passing an RGB space as an option (either to the constructor or later) will have an effect on the values.

Bio::Graphics::FeatureFile is a set of Bio::Graphics features, stored in a file.

SYNOPSIS

use Bio::Graphics::FeatureFile;
my $data = Bio::Graphics::FeatureFile->new(-file => features.txt);


# create a new panel and render contents of the file onto it
my $panel = $data->new_panel;
my $tracks_rendered = $data->render($panel);

# or do it all in one step
my ($tracks_rendered,$panel) = $data->render;

# for more control, render tracks individually
my @feature_types = $data->types;
for my $type (@feature_types) {
my $features = $data->features($type);
my %options = $data->style($type);
$panel->add_track($features,%options); # assuming we have a Bio::Graphics::Panel
}

# get individual settings
my $est_fg_color = $data->setting(EST => fgcolor);

# or create the FeatureFile by hand

# add a type
$data->add_type(EST => {fgcolor=>blue,height=>12});

# add a feature
my $feature = Bio::Graphics::Feature->new(
# params
); # or some other SeqI
$data->add_feature($feature=>EST);

The Bio::Graphics::FeatureFile module reads and parses files that describe sequence features and their renderings. It accepts both GFF format and a more human-friendly file format described below. Once a FeatureFile object has been initialized, you can interrogate it for its consistuent features and their settings, or render the entire file onto a Bio::Graphics::Panel.

This moduel is a precursor of Jason Stajichs Bio::Annotation::Collection class, and fulfills a similar function of storing a collection of sequence features. However, it also stores rendering information about the features, and does not currently follow the CollectionI interface.