Free directx 9.0c compatible graphics adapter software for linux

SAgl is a portable small antialiased graphics library. It offers lines, circles, and bezier curves, as well as thick lines and fills.

It can be used on top of SDL or with X or any other graphics system.

Bio::Tree::Compatible is a Perl module for testing compatibility of phylogenetic trees with nested taxa.

SYNOPSIS

use Bio::Tree::Compatible;
use Bio::TreeIO;
my $input = new Bio::TreeIO(-format => newick,
-file => input.tre);
my $t1 = $input->next_tree;
my $t2 = $input->next_tree;

my ($incompat, $ilabels, $inodes) = $t1->is_compatible($t2);
if ($incompat) {
my %cluster1 = %{ $t1->cluster_representation };
my %cluster2 = %{ $t2->cluster_representation };
print "incompatible treesn";
if (scalar(@$ilabels)) {
foreach my $label (@$ilabels) {
my $node1 = $t1->find_node(-id => $label);
my $node2 = $t2->find_node(-id => $label);
my @c1 = sort @{ $cluster1{$node1} };
my @c2 = sort @{ $cluster2{$node2} };
print "label $label";
print " cluster"; map { print " ",$_ } @c1;
print " cluster"; map { print " ",$_ } @c2; print "n";
}
}
if (scalar(@$inodes)) {
while (@$inodes) {
my $node1 = shift @$inodes;
my $node2 = shift @$inodes;
my @c1 = sort @{ $cluster1{$node1} };
my @c2 = sort @{ $cluster2{$node2} };
print "cluster"; map { print " ",$_ } @c1;
print " properly intersects cluster";
map { print " ",$_ } @c2; print "n";
}
}
} else {
print "compatible treesn";
}

Bio::Tree::Compatible is a Perl tool for testing compatibility of phylogenetic trees with nested taxa represented as Bio::Tree::Tree objects. It is based on a recent characterization of ancestral compatibility of semi-labeled trees in terms of their cluster representations.

A semi-labeled tree is a phylogenetic tree with some of its internal nodes labeled, and it can represent a classification tree as well as a phylogenetic tree with nested taxa, with labeled internal nodes corresponding to taxa at a higher level of aggregation or nesting than that of their descendents.

Two semi-labeled trees are compatible if their topological restrictions to the common labels are such that for each node label, the smallest clusters containing it in each of the trees coincide and, furthermore, no cluster in one of the trees properly intersects a cluster of the other tree.

Future extensions of Bio::Tree::Compatible include a Bio::Tree::Supertree module for combining compatible phylogenetic trees with nested taxa into a common supertree.

CAD::Drawing::Manipulate::Graphics - Gimp meets CAD.

Methods

All of these are CAD::Drawing methods (I force my own inheritance:)

image_init

Initialize the image at $addr based on the value at the fullpath key. This establishes the contained Image::Magick object and loads the image into memory in the image_handle key.

$drw->image_init($addr);

image_crop

Crops an image and its definition (actually, changes its insert point) according to the points given by @crop_points (which maybe had better be within the object (but I dont really sweat that.))

@crop_points should be in world coordinates as follows:

@crop_points = (
[$lower_left_x , $lower_left_y ],
[$upper_right_x, $upper_right_y],
);
# note that you can get these as
# ($drw->getExtentsRec($something))[0,2]

$drw->image_crop($addr, @crop_points);

image_scale

Scales both the image and the definition by $scale, starting at @base_point.

$drw->image_scale($addr, $scale, @base_point);

image_rotate

This leaves the definition orthoganal, expands the underlying image object, and resets the insert point and size properties accordingly.

$drw->image_rotate($addr, $angle, @point);

The current implementation does not handle the change to the image clipping boundary.

image_swap_context

This involves a scaling of the image (the contexts should be aligned over each other at this point or everything will go to hell.) Do your own move / rotate / crop before calling this, because all this does is to scale the underlying image object such that the vec property of the image definition at $dest_addr can be used correctly.

Note that this does not "swap" the image to $dest_addr, rather it uses the image definition of $dest_addr to change the image object and definition at $source_addr.
Also note that the image must fit completely inside (I think) of the destination in order for the composite to work correctly.

$drw->image_swap_context($source_addr, $dest_addr);

PDL::Graphics::TriD is a PDL 3D interface.

SYNOPSIS

use PDL::Graphics::TriD;

# After each graph, let the user rotate is and # wait for him to press q, then make new graph line3d($coords); # $coords = (3,n,...) line3d($coords,$colors); # $colors = (3,n,...) line3d([$x,$y,$z]); imagrgb([$r,$g,$b]); lattice3d([$x,$y,$z]); # 2-d piddles points3d([$x,$y,$z]);
hold3d(); # the following graphs are on top of each other and the previous line3d([$x,$y,$z]); line3d([$x,$y,$z+1]); $pic = grabpic3d(); # Returns the picture in a (3,$x,$y) float piddle (0..1).
release3d(); # the next graph will again wipe out things.

WARNING

These modules are still in a somewhat unfocused state: dont use them yet if you dont know how to make them work if they happen to do something strange.

This module implements a generic 3D plotting interface for PDL. Points, lines and surfaces (among other objects) are supported.

With OpenGL, it is easy to manipulate the resulting 3D objects with the mouse in real time - this helps data visualization a lot.

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

Text::Graphics is a text graphics rendering toolkit.

This is a toolkit for rendering plain text via an API like that used for graphics rendering in GUI toolkits. This package might be used when you want to do sophisticated rendering of plain text, e.g., for graphing, creating of complex forms for email and fax, and so on.

SYNOPSIS

use Text::Graphics;
my $text = "A text graphics rendering toolkit.n";
my $page = Text::Graphics::Page->new( 20, 10);
my $panel0 = Text::Graphics::BorderedPanel->new( 20, 10);
my $panel1 =
Text::Graphics::FilledBorderedTextPanel->new($text x 3, 25, 12);
$panel0->setBackground("#");
$panel1->setBackground(" ");
$page->add($panel0);
$page->add($panel1, 5, 2);
$page->render();

+-------------------+
|###################|
|####+--------------+
|####|A text graphic|
|####|rendering tool|
|####|text graphics |
|####|toolkit. A tex|
|####|graphics rende|
|####|toolkit. |
|####| |
+----+--------------+

PDL::Graphics::X is a PDL OO access to X windows.

SYNOPSIS

# example 1

use PDL;
use PDL::Graphics::X;

my $x_size = 255; my $y_size = 255;
my $win1 = PDL::Graphics::X->new({SIZE_X => $x_size, SIZE_Y => $y_size});
my $a = xvals(zeroes(byte,$x_size,$y_size));
$win1->imag($a);

# example 2

use PDL;
use PDL::Graphics::X;

my $win1 = PDL::Graphics::X->new({WIN_TITLE => "PDL", SIZE_X => 210, SIZE_Y => 210});
my $x = pdl(10, 100, 100, 10);
my $y = pdl(10, 10, 100, 100);
$win1->line($x, $y, {COLOR => [1,0,0], LINEWIDTH => 5});

This module interfaces PDL directly to X windows in a OO fashion. Each X object has an associated X window and handles opening, closing and drawing in the associated window. Hopefully it is reasonably intuitive to use. The vision is that this will serve as a base upon which other fully native PDL graphics modules could be built.

Common options such as LINEWIDTH are remembered from function call to function call, i.e. if you call $win1->line($x, $y, {COLOR => [1,0,0], LINEWIDTH => 5}) then the rectangle drawn by $win1->rect(10, 10, 190, 190) will also have a red border of width equal to 5.

FUNCTIONS

new

Constructor for a new X window object.

Usage: my $win1 = PDL::Graphics::X->new(); # open the window with the defaults
Usage: my $win1 = PDL::Graphics::X->new({WIN_TITLE => "PDL", SIZE_X => 210, SIZE_Y => 210});

Creates a new X object & its associated X window.

Options recognized :

SIZE_X - window x size in pixels (default = 400)
SIZE_Y - window y size in pixels (default = 300)
WIN_TITLE - A title for the window, if desired (default = "X")
BACK_COLOR - [r, g, b] the windows background color (default = [1.0, 1.0, 1.0], i.e. white)
imag

Display a PDL as a bitmap.

Usage: $win1->imag($my_img); # display an image with default size and scaling
Usage: $win1->imag($my_img, {AUTO_SCALE => 1.0}); # display an auto-scaled image

Displays a PDL as a bitmap. The PDL can be of size either (m,n) or (m,n,3). PDLs of size (m,n) are converted to indexed color based on the current color table (see ctab). PDLs of size (m,n,3) are displayed as true-color images with the last dimension specifying the color (RGB). Unless a re-scaling is specified, the minimum value displayed is 0.0 and the maximum is 255.0. If the PDL is larger then the window then the window will be re-scaled to accomodate the PDL;

Options recognized :

DEST_X - position of the left side of the bitmap in pixels (default = 0)
DEST_Y - position of the bottom of the bitmap in pixels (default = 0)
DEST_W - width of the bitmap to be displayed (default = width of the PDL)
DEST_H - height of the bitmap to be displayed (default = height of the PDL)
AUTO_SCALE - if set equal to 1, the PDL will be rescaled such that its
minimum value is 1 and its max is 255 (default = 0)
MIN - the minimum value to be displayed (default = 0.0)
MAX - the maximum value to be displayed (default = 255.0)
ctab

Set the color table

Usage: $win1->ctab(cat(lut_data(idl5))); # set the color table to idl5

Makes a local copy of a user supplied color table. The color table must be a 256 x 4 pdl of the form (l,r,g,b), as would be generated by the command $ct = cat(lut_data("xyz")). The l value is ignored. The r, g and b values should be in the range 0.0 - 1.0.

line

Draws a vector as connected points.

Usage: $win1->line($x, $y, {COLOR => [0,0,0], LINEWIDTH => 5}); # draw black line of width 5

Draw a poly-line between a set of points given by two PDLs of size (n). The first PDL gives the x position & the second piddle gives the y position of the individual points, n is the total number of points.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
rect

Draws a rectangle.

Usage: $win1->rect($x1, $y1, $x2, $y2);

Draws a rectangle with corners at ($x1, $y1) and ($x2, $y2).

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
circle

Draws a circle.

Usage: $win1->circle($x, $y, $r);

Draws a circle centered at ($x, $y) with radius $r.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
ellipse

Draws an oval.

Usage: $win1->ellipse($x, $y, $a, $b);

Draws a oval centered at ($x, $y) with x size $a and y size $b.

Options recognized

LINEWIDTH - line width
LINESTYLE - line style (0 = normal, 1 = dashed)
COLOR - [r, g, b] color of the line
erase

Erases the contents of the window.

Usage: $win1->erase();

Resets the contents of the window to the background color.

text

Draw text

Usage: $win1->text("hello", $x, $y, $angle);

Draws text starting at $x and $y with baseline angle given by $angle. If you know how to draw truly rotated text in X, please let me know. How fonts are currently dealt with is imperfect at best. So that the font size can easily be changed, a search is performed for a scalable font with specified font name. If such a font cannot be found then the text will be displayed with the default X font and no font scaling.

Options recognized

FONT_NAME - name of the font family (default = "courier")
CHARSIZE - desired font size in points
COLOR - [r, g, b] color of the font

cursor

Returns the location of next mouse click in the window

Usage : my($x,$y) = $win1->cursor();

Returns the x & y locations of the next mouse click in the window.

we_exist

Returns 0 if the window still exists, 1 if it does not

Usage : my $exists = $win1->we_exist();

Originally written to help debug some problems with associated with X windows being closed by the user with a mouse. Preserved on the off chance that it will be useful to a dependent module.

winsize

Returns the window size & maximum window size (in pixels) in x and y

Usage : my ($win_x, $win_y, $max_x, $max_y) = $win1->winsize();

Primarily intended for use by dependent modules that might want to know what the current and maximum window size is.

resize

resizes a window & returns the new size (which might not be what you requested)

Usage : my ($new_x, $new_y) = $win1->resize($size_x, $size_y);

Primarily intended for use by dependent modules that might want to resize a window without destroying it and creating another one.