transform
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 272
PDL::Transform 2.4.3
PDL::Transform is a Perl module that coordinate transforms, image warping, and N-D functions. more>>
PDL::Transform is a Perl module that coordinate transforms, image warping, and N-D functions.
SYNOPSIS
use PDL::Transform;
my $t = new PDL::Transform:: ( )
$out = $t->apply($in) # Apply transform to some N-vectors (Transform method)
$out = $in->apply($t) # Apply transform to some N-vectors (PDL method)
$im1 = $t->map($im); # Transform image coordinates (Transform method)
$im1 = $im->map($t); # Transform image coordinates (PDL method)
$t2 = $t->compose($t1); # compose two transforms
$t2 = $t x $t1; # compose two transforms (by analogy to matrix mult.)
$t3 = $t2->inverse(); # invert a transform
$t3 = !$t2; # invert a transform (by analogy to logical "not")
PDL::Transform is a convenient way to represent coordinate transformations and resample images. It embodies functions mapping R^N -> R^M, both with and without inverses. Provision exists for parametrizing functions, and for composing them. You can use this part of the Transform object to keep track of arbitrary functions mapping R^N -> R^M with or without inverses.
The simplest way to use a Transform object is to transform vector data between coordinate systems. The apply method accepts a PDL whose 0th dimension is coordinate index (all other dimensions are threaded over) and transforms the vectors into the new coordinate system.
Transform also includes image resampling, via the map method. You define a coordinate transform using a Transform object, then use it to remap an image PDL. The output is a remapped, resampled image.
You can define and compose several transformations, then apply them all at once to an image. The image is interpolated only once, when all the composed transformations are applied.
In keeping with standard practice, but somewhat counterintuitively, the map engine uses the inverse transform to map coordinates FROM the destination dataspace (or image plane) TO the source dataspace; hence PDL::Transform keeps track of both the forward and inverse transform.
For terseness and convenience, most of the constructors are exported into the current package with the name t_ , so the following (for example) are synonyms:
$t = new PDL::Transform::Radial(); # Long way
$t = t_radial(); # Short way
Several math operators are overloaded, so that you can compose and invert functions with expression syntax instead of method syntax (see below).
<<lessSYNOPSIS
use PDL::Transform;
my $t = new PDL::Transform:: ( )
$out = $t->apply($in) # Apply transform to some N-vectors (Transform method)
$out = $in->apply($t) # Apply transform to some N-vectors (PDL method)
$im1 = $t->map($im); # Transform image coordinates (Transform method)
$im1 = $im->map($t); # Transform image coordinates (PDL method)
$t2 = $t->compose($t1); # compose two transforms
$t2 = $t x $t1; # compose two transforms (by analogy to matrix mult.)
$t3 = $t2->inverse(); # invert a transform
$t3 = !$t2; # invert a transform (by analogy to logical "not")
PDL::Transform is a convenient way to represent coordinate transformations and resample images. It embodies functions mapping R^N -> R^M, both with and without inverses. Provision exists for parametrizing functions, and for composing them. You can use this part of the Transform object to keep track of arbitrary functions mapping R^N -> R^M with or without inverses.
The simplest way to use a Transform object is to transform vector data between coordinate systems. The apply method accepts a PDL whose 0th dimension is coordinate index (all other dimensions are threaded over) and transforms the vectors into the new coordinate system.
Transform also includes image resampling, via the map method. You define a coordinate transform using a Transform object, then use it to remap an image PDL. The output is a remapped, resampled image.
You can define and compose several transformations, then apply them all at once to an image. The image is interpolated only once, when all the composed transformations are applied.
In keeping with standard practice, but somewhat counterintuitively, the map engine uses the inverse transform to map coordinates FROM the destination dataspace (or image plane) TO the source dataspace; hence PDL::Transform keeps track of both the forward and inverse transform.
For terseness and convenience, most of the constructors are exported into the current package with the name t_ , so the following (for example) are synonyms:
$t = new PDL::Transform::Radial(); # Long way
$t = t_radial(); # Short way
Several math operators are overloaded, so that you can compose and invert functions with expression syntax instead of method syntax (see below).
Download (2.1MB)
Added: 2007-07-03 License: Perl Artistic License Price:
847 downloads
Grid::Transform 0.02
Grid::Transform is a Perl module with fast grid transformations. more>>
Grid::Transform is a Perl module with fast grid transformations.
SYNOPSIS
use Grid::Transform;
$g = Grid::Transform->new([a..o], rows=>5);
$g->rotate_270->flip_vertical;
print join( , $g->grid), "n";
The Grid::Transform module provides fast methods to transform a grid of arbitrary data types.
METHODS
$g = Grid::Transform->new( @grid, rows=>num, columns=>num )
Creates a new Grid::Transform object. The first argument is a reference to a 1-dimensional array representing a 2-dimensional "row major" (row by row) grid. (A column major grid is simply the counter transpose of a row major one.) The grid may be composed of arbitrary data types. The original array is never modified- all transformations operate on a copy.
At least one dimension must be specified. If the grid and dimensions do not produce a rectangular grid extra empty elements ("") will be added to the grid.
$g2 = $g->copy
Returns a copy of the original Grid::Transform object.
These methods get or set the grid attributes:
@grid = $g->grid
$grid = $g->grid
@grid = $g->grid( @grid )
In list context, returns an array representing the current grid. In scalar context, returns a reference to the array. Accepts an array reference representing a new grid. The new grid will be resized if the dimensions of the previous grid do not match.
$g->rows
$g->rows( $num )
Returns the current number of rows.
$g->columns
$g->cols
$g->columns( $num )
Returns the current number of columns.
All transform methods return the Grid::Transform object, so transforms can be chained.
$g->rotate_90
$g->rotate90
Rotates the grid 90 degrees clock-wise.
a b c d e f g h i j k l a b c d i e a
| e f g h -> j f b
i e a j f b k g c l h d i j k l k g c
l h d
$g->rotate_180
$g->rotate180
Rotates the grid 180 degrees clock-wise.
a b c d e f g h i j k l a b c d l k j i
| e f g h -> h g f e
l k j i h g f e d c b a i j k l d c b a
$g->rotate_270
$g->rotate270
Rotates the grid 270 degrees clock-wise.
a b c d e f g h i j k l a b c d d h l
| e f g h -> c g k
d h l c g k b f j a e i i j k l b f j
a e i
$g->flip_horizontal
$g->mirror_horizontal
Flips the grid across the horizontal axis.
a b c d e f g h i j k l a b c d i j k l
| e f g h -> e f g h
i j k l e f g h a b c d i j k l a b c d
$g->flip_vertical
$g->mirror_vertical
Flips the grid across the vertical axis.
a b c d e f g h i j k l a b c d d c b a
| e f g h -> h g f e
d c b a h g f e l k j i i j k l l k j i
$g->transpose
Flips the grid across the vertical axis and then rotates it 90 degress clock-wise.
a b c d e f g h i j k l a b c d l h d
| e f g h -> k g c
l h d k g c j f b i e a i j k l j f b
i e a
$g->counter_transpose
$g->countertranspose
Flips the grid across the horizontal axis and then rotates it 90 degrees clock-wise.
a b c d e f g h i j k l a b c d a e i
| e f g h -> b f j
a e i b f j c g k d h l i j k l c g k
d h l
$g->fold_right
Folds the columns to the right.
a b c d e f g h i j k l a b c d b c d a
| e f g h -> f g e h
b c a d f g e h j k i l i j k l j k i l
$g->fold_left
Folds the columns to the left.
a b c d e f g h i j k l a b c d d a c b
| e f g h -> h e g f
d a c b h e g f l i k j i j k l l i k j
<<lessSYNOPSIS
use Grid::Transform;
$g = Grid::Transform->new([a..o], rows=>5);
$g->rotate_270->flip_vertical;
print join( , $g->grid), "n";
The Grid::Transform module provides fast methods to transform a grid of arbitrary data types.
METHODS
$g = Grid::Transform->new( @grid, rows=>num, columns=>num )
Creates a new Grid::Transform object. The first argument is a reference to a 1-dimensional array representing a 2-dimensional "row major" (row by row) grid. (A column major grid is simply the counter transpose of a row major one.) The grid may be composed of arbitrary data types. The original array is never modified- all transformations operate on a copy.
At least one dimension must be specified. If the grid and dimensions do not produce a rectangular grid extra empty elements ("") will be added to the grid.
$g2 = $g->copy
Returns a copy of the original Grid::Transform object.
These methods get or set the grid attributes:
@grid = $g->grid
$grid = $g->grid
@grid = $g->grid( @grid )
In list context, returns an array representing the current grid. In scalar context, returns a reference to the array. Accepts an array reference representing a new grid. The new grid will be resized if the dimensions of the previous grid do not match.
$g->rows
$g->rows( $num )
Returns the current number of rows.
$g->columns
$g->cols
$g->columns( $num )
Returns the current number of columns.
All transform methods return the Grid::Transform object, so transforms can be chained.
$g->rotate_90
$g->rotate90
Rotates the grid 90 degrees clock-wise.
a b c d e f g h i j k l a b c d i e a
| e f g h -> j f b
i e a j f b k g c l h d i j k l k g c
l h d
$g->rotate_180
$g->rotate180
Rotates the grid 180 degrees clock-wise.
a b c d e f g h i j k l a b c d l k j i
| e f g h -> h g f e
l k j i h g f e d c b a i j k l d c b a
$g->rotate_270
$g->rotate270
Rotates the grid 270 degrees clock-wise.
a b c d e f g h i j k l a b c d d h l
| e f g h -> c g k
d h l c g k b f j a e i i j k l b f j
a e i
$g->flip_horizontal
$g->mirror_horizontal
Flips the grid across the horizontal axis.
a b c d e f g h i j k l a b c d i j k l
| e f g h -> e f g h
i j k l e f g h a b c d i j k l a b c d
$g->flip_vertical
$g->mirror_vertical
Flips the grid across the vertical axis.
a b c d e f g h i j k l a b c d d c b a
| e f g h -> h g f e
d c b a h g f e l k j i i j k l l k j i
$g->transpose
Flips the grid across the vertical axis and then rotates it 90 degress clock-wise.
a b c d e f g h i j k l a b c d l h d
| e f g h -> k g c
l h d k g c j f b i e a i j k l j f b
i e a
$g->counter_transpose
$g->countertranspose
Flips the grid across the horizontal axis and then rotates it 90 degrees clock-wise.
a b c d e f g h i j k l a b c d a e i
| e f g h -> b f j
a e i b f j c g k d h l i j k l c g k
d h l
$g->fold_right
Folds the columns to the right.
a b c d e f g h i j k l a b c d b c d a
| e f g h -> f g e h
b c a d f g e h j k i l i j k l j k i l
$g->fold_left
Folds the columns to the left.
a b c d e f g h i j k l a b c d d a c b
| e f g h -> h e g f
d a c b h e g f l i k j i j k l l i k j
Download (0.036MB)
Added: 2007-05-18 License: Perl Artistic License Price:
890 downloads
PDL::Transform::Cartography 2.4.3
PDL::Transform::Cartography Perl module contains useful cartographic projections. more>>
PDL::Transform::Cartography Perl module contains useful cartographic projections.
SYNOPSIS
# make a Mercator map of Earth
use PDL::Transform::Cartography;
$a = earth_coast();
$a = graticule(10,2)->glue(1,$a);
$t = t_mercator;
$w = pgwin(xs);
$w->lines($t->apply($a)->clean_lines());
PDL::Transform::Cartography includes a variety of useful cartographic and observing projections (mappings of the surface of a sphere), including reprojected observer coordinates. See PDL::Transform for more information about image transforms in general.
Cartographic transformations are used for projecting not just terrestrial maps, but also any nearly spherical surface including the Sun, the Celestial sphere, various moons and planets, distant stars, etc. They also are useful for interpreting scientific images, which are themselves generally projections of a sphere onto a flat focal plane (e.g. the t_gnomonic projection).
Unless otherwise noted, all the transformations in this file convert from (theta,phi) coordinates on the unit sphere (e.g. (lon,lat) on a planet or (RA,dec) on the celestial sphere) into some sort of projected coordinates, and have inverse transformations that convert back to (theta,phi). This is equivalent to working from the equidistant cylindrical (or "plate caree") projection, if you are a cartography wonk.
The projected coordinates are generally in units of body radii (radians), so that multiplying the output by the scale of the map yields physical units that are correct wherever the scale is correct for that projection. For example, areas should be correct everywhere in the authalic projections; and linear scales are correct along meridians in the equidistant projections and along the standard parallels in all the projections.
The transformations that are authalic (equal-area), conformal (equal-angle), azimuthal (circularly symmetric), or perspective (true perspective on a focal plane from some viewpoint) are marked. The first two categories are mutually exclusive for all but the "unit sphere" 3-D projection.
Extra dimensions tacked on to each point to be transformed are, in general, ignored. That is so that you can add on an extra index to keep track of pen color. For example, earth_coast returns a 3x< n > piddle containing (lon, lat, pen) at each list location. Transforming the vector list retains the pen value as the first index after the dimensional directions.
<<lessSYNOPSIS
# make a Mercator map of Earth
use PDL::Transform::Cartography;
$a = earth_coast();
$a = graticule(10,2)->glue(1,$a);
$t = t_mercator;
$w = pgwin(xs);
$w->lines($t->apply($a)->clean_lines());
PDL::Transform::Cartography includes a variety of useful cartographic and observing projections (mappings of the surface of a sphere), including reprojected observer coordinates. See PDL::Transform for more information about image transforms in general.
Cartographic transformations are used for projecting not just terrestrial maps, but also any nearly spherical surface including the Sun, the Celestial sphere, various moons and planets, distant stars, etc. They also are useful for interpreting scientific images, which are themselves generally projections of a sphere onto a flat focal plane (e.g. the t_gnomonic projection).
Unless otherwise noted, all the transformations in this file convert from (theta,phi) coordinates on the unit sphere (e.g. (lon,lat) on a planet or (RA,dec) on the celestial sphere) into some sort of projected coordinates, and have inverse transformations that convert back to (theta,phi). This is equivalent to working from the equidistant cylindrical (or "plate caree") projection, if you are a cartography wonk.
The projected coordinates are generally in units of body radii (radians), so that multiplying the output by the scale of the map yields physical units that are correct wherever the scale is correct for that projection. For example, areas should be correct everywhere in the authalic projections; and linear scales are correct along meridians in the equidistant projections and along the standard parallels in all the projections.
The transformations that are authalic (equal-area), conformal (equal-angle), azimuthal (circularly symmetric), or perspective (true perspective on a focal plane from some viewpoint) are marked. The first two categories are mutually exclusive for all but the "unit sphere" 3-D projection.
Extra dimensions tacked on to each point to be transformed are, in general, ignored. That is so that you can add on an extra index to keep track of pen color. For example, earth_coast returns a 3x< n > piddle containing (lon, lat, pen) at each list location. Transforming the vector list retains the pen value as the first index after the dimensional directions.
Download (2.1MB)
Added: 2007-07-21 License: Perl Artistic License Price:
3943 downloads
CAD::Drawing::Manipulate::Transform 0.26
CAD::Drawing::Manipulate::Transform is a Perl module with Matrix methods for CAD::Drawing. more>>
CAD::Drawing::Manipulate::Transform is a Perl module with Matrix methods for CAD::Drawing.
Provides 3D transformation methods (based on traditional matrix algorithms) for Drawing.pm objects.
Coordinate System
All of these methods assume a RIGHT-HANDED coordinate system. If you are using a left-handed coordinate system, you are going to have trouble, trouble, trouble. We arent making video games here!
<<lessProvides 3D transformation methods (based on traditional matrix algorithms) for Drawing.pm objects.
Coordinate System
All of these methods assume a RIGHT-HANDED coordinate system. If you are using a left-handed coordinate system, you are going to have trouble, trouble, trouble. We arent making video games here!
Download (0.039MB)
Added: 2007-03-16 License: GPL (GNU General Public License) Price:
953 downloads
Parallel Three-Dimensional Fast Fourier Transforms 2.1
Parallel Three-Dimensional Fast Fourier Transforms is a library for computational computing in a wide range of sciences. more>>
Parallel Three-Dimensional Fast Fourier Transforms, dubbed P3DFFT, is a library for computational computing in a wide range of sciences, such as physics, climatology, chemistry.
This project was developed at SDSC by Dmitry Pekurovsky as a product of a Strategic Applications Collaborations (SAC) project.
Main features:
- Parallel implementation with 2D data decomposition, overcoming an important limitation to scalability of other 3D FFT libraries implementing 1D, or slab, decomposition.
- Optimized for parallel communication and single-CPU performance.
- Built on top of well-optimized and flexible 1D FFT libraries.
Enhancements:
- Assorted minor bugfixes and code speedups.
<<lessThis project was developed at SDSC by Dmitry Pekurovsky as a product of a Strategic Applications Collaborations (SAC) project.
Main features:
- Parallel implementation with 2D data decomposition, overcoming an important limitation to scalability of other 3D FFT libraries implementing 1D, or slab, decomposition.
- Optimized for parallel communication and single-CPU performance.
- Built on top of well-optimized and flexible 1D FFT libraries.
Enhancements:
- Assorted minor bugfixes and code speedups.
Download (MB)
Added: 2007-06-07 License: GPL (GNU General Public License) Price:
869 downloads
Trf 2.1p2
Trf is an extension library to the script language tcl, as created by John Ousterhout. more>>
Trf is an extension library to the script language tcl, as created by John Ousterhout. It extends the language at the C-level with so-called "transformer"-procedures.
With the help of some patches to the core the package is able to intercept all read/write operations on designated channels, thus giving it the ability to transform the buffer contents as desired.
Existing transforms include Base64, UUencode, Hashes (SHA, MD5, ...), error correction codec, zlib-based compression, script level transforms.
<<lessWith the help of some patches to the core the package is able to intercept all read/write operations on designated channels, thus giving it the ability to transform the buffer contents as desired.
Existing transforms include Base64, UUencode, Hashes (SHA, MD5, ...), error correction codec, zlib-based compression, script level transforms.
Download (1.6MB)
Added: 2006-06-02 License: BSD License Price:
1239 downloads
Parrot::OpTrans 0.4.5
Parrot::OpTrans is a Perl module that can transform Ops to C Code. more>>
Parrot::OpTrans is a Perl module that can transform Ops to C Code.
Parrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.
The subclass hierarchy is as follows:
OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP
Class Methods
new()
Returns a new instance.
Instance Methods
prefix()
Returns the default Parrot_ prefix.
Used by Parrot::Ops func_name() to individuate op function names.
suffix()
Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.
defines()
Implemented in subclasses to return the C #define macros required.
opsarraytype()
Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.
core_type()
Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.
core_prefix()
Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.
run_core_func_decl($base)
Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.
ops_addr_decl($base_suffix)
Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.
run_core_func_decl($base)
Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().
run_core_func_start()
Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.
run_core_after_addr_table($base_suffix)
Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().
run_core_finish($base)
Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().
init_func_init1($base)
Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().
init_set_dispatch($base_suffix)
Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().
Macro Substitutions
The following methods are called by Parrot::OpFile to perform ops file macro substitutions.
access_arg($type, $value, $op)
Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.
gen_goto($where)
The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).
restart_address($address)
Implemented in subclasses to return the C code for restart ADDRESS($address).
restart_offset($offset)
Implemented in subclasses to return the C code for restart OFFSET($offset).
goto_address($address)
Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.
goto_offset($offset)
Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.
goto_pop()
Transforms the goto POP($address) macro in an ops file into the relevant C code.
expr_offset($offset)
Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().
expr_address($address)
Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().
<<lessParrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.
The subclass hierarchy is as follows:
OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP
Class Methods
new()
Returns a new instance.
Instance Methods
prefix()
Returns the default Parrot_ prefix.
Used by Parrot::Ops func_name() to individuate op function names.
suffix()
Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.
defines()
Implemented in subclasses to return the C #define macros required.
opsarraytype()
Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.
core_type()
Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.
core_prefix()
Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.
run_core_func_decl($base)
Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.
ops_addr_decl($base_suffix)
Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.
run_core_func_decl($base)
Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().
run_core_func_start()
Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.
run_core_after_addr_table($base_suffix)
Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().
run_core_finish($base)
Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().
init_func_init1($base)
Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().
init_set_dispatch($base_suffix)
Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().
Macro Substitutions
The following methods are called by Parrot::OpFile to perform ops file macro substitutions.
access_arg($type, $value, $op)
Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.
gen_goto($where)
The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).
restart_address($address)
Implemented in subclasses to return the C code for restart ADDRESS($address).
restart_offset($offset)
Implemented in subclasses to return the C code for restart OFFSET($offset).
goto_address($address)
Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.
goto_offset($offset)
Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.
goto_pop()
Transforms the goto POP($address) macro in an ops file into the relevant C code.
expr_offset($offset)
Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().
expr_address($address)
Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().
Download (3.1MB)
Added: 2006-07-06 License: Perl Artistic License Price:
1205 downloads
autopano-sift 2.3
A helper utility for automated panorama image generation. more>>
Panorama images are wide-angle images that amaze people: you often feel
being inside the scene when watching a good panorama image.
Creating such images is easy and everybody with a digital camera and a bit of patience can do it. Autopano-SIFT is there to make the creation of panorama images more fun.
Main features:
- SIFT - Scalable Invariant Feature Transform implementation to extract control points from images
- automatic pre-aligning of images
- sub-pixel coordinate precision for control point coordinates
- Linux, other Unixs and Windows supported
GUIs:
- Gtk# GUI
- Windows native GUI
- Command line utilities
- 100% managed C# code, developed with Mono
<<lessbeing inside the scene when watching a good panorama image.
Creating such images is easy and everybody with a digital camera and a bit of patience can do it. Autopano-SIFT is there to make the creation of panorama images more fun.
Main features:
- SIFT - Scalable Invariant Feature Transform implementation to extract control points from images
- automatic pre-aligning of images
- sub-pixel coordinate precision for control point coordinates
- Linux, other Unixs and Windows supported
GUIs:
- Gtk# GUI
- Windows native GUI
- Command line utilities
- 100% managed C# code, developed with Mono
Download (0.66MB)
Added: 2005-05-19 License: GPL (GNU General Public License) Price:
1621 downloads
Widelands Build 10rc
Widelands is a clone of Bluebytes Settlers II. more>>
Widelands is a clone of Bluebytes Settlers II.
Like in warcraft-like games, you are the despot of an empire and want to harvest resources and get soldiers to get more power.
Unlike those games, this is a strategic game, not a tactic one, and the main point is about economy instead of war.
Lumberjack get logs that you have to transform to planks in the sawmill, and so on. You could say that its an economy simulation game. The world is something between middle age and roman empire.
<<lessLike in warcraft-like games, you are the despot of an empire and want to harvest resources and get soldiers to get more power.
Unlike those games, this is a strategic game, not a tactic one, and the main point is about economy instead of war.
Lumberjack get logs that you have to transform to planks in the sawmill, and so on. You could say that its an economy simulation game. The world is something between middle age and roman empire.
Download (29MB)
Added: 2007-03-05 License: GPL (GNU General Public License) Price:
964 downloads
InterXim 0.0.4
InterXim is an international X11 XIM server. more>>
InterXim project is an international, locale-independent X11 XIM server.
It translates ASCII key sequences to Unicode.
The converter uses the Yudit kmap files to transform the ASCII string to Unicode KeySym.
<<lessIt translates ASCII key sequences to Unicode.
The converter uses the Yudit kmap files to transform the ASCII string to Unicode KeySym.
Download (0.52MB)
Added: 2006-09-30 License: GPL (GNU General Public License) Price:
1119 downloads
GFourier 0.4.1
GFourier can help you use Fourier Analysis for image restoration. more>>
GFourier can help you use Fourier Analysis for image restoration.
GFourier calculates the Fourier Transform of a given image and allows the use of filters in the frequency domain. The Inverse Fourier Transform is then used to substitute original image.
<<lessGFourier calculates the Fourier Transform of a given image and allows the use of filters in the frequency domain. The Inverse Fourier Transform is then used to substitute original image.
Download (0.064MB)
Added: 2006-09-15 License: GPL (GNU General Public License) Price:
1141 downloads
Bio::AlignIO::msf 1.4
Bio::AlignIO::msf is a Perl module with msf sequence input/output stream. more>>
Bio::AlignIO::msf is a Perl module with msf sequence input/output stream.
SYNOPSIS
Do not use this module directly. Use it via the Bio::AlignIO class.
This object can transform Bio::Align::AlignI objects to and from msf flat file databases.
The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _
next_aln
Title : next_aln
Usage : $aln = $stream->next_aln()
Function: returns the next alignment in the stream. Tries to read *all* MSF
It reads all non whitespace characters in the alignment
area. For MSFs with weird gaps (eg ~~~) map them by using
$al->map_chars(~,-)
Returns : L< Bio::Align::AlignI > object
Args : NONE
write_aln
Title : write_aln
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in MSF format
Sequence type of the alignment is determined by the first sequence.
Returns : 1 for success and 0 for error
Args : L< Bio::Align::AlignI > object
<<lessSYNOPSIS
Do not use this module directly. Use it via the Bio::AlignIO class.
This object can transform Bio::Align::AlignI objects to and from msf flat file databases.
The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _
next_aln
Title : next_aln
Usage : $aln = $stream->next_aln()
Function: returns the next alignment in the stream. Tries to read *all* MSF
It reads all non whitespace characters in the alignment
area. For MSFs with weird gaps (eg ~~~) map them by using
$al->map_chars(~,-)
Returns : L< Bio::Align::AlignI > object
Args : NONE
write_aln
Title : write_aln
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in MSF format
Sequence type of the alignment is determined by the first sequence.
Returns : 1 for success and 0 for error
Args : L< Bio::Align::AlignI > object
Download (4.7MB)
Added: 2006-09-29 License: Perl Artistic License Price:
1121 downloads
Clover framework 2.2.0
Clover.ETL is a Java based ETL framework. more>>
Clover.ETL is a Java based ETL framework which can be used to transform structured data. While using JAVA technology it allows for platform independence.
Clover framework can be used standalone as an application run from command line or can be embedded into Your application. Clover.ETL is released under LGPL License.
Clover.ETL is used by many individual developers and several companies, which embeds it into their solutions.
Enhancements:
- The internal transformation language has been improved.
- All reader and writer components support the same set of parameters (dataPolicy, skipFirstLine, skipRows, numRecords, etc.).
- Several new transformation components have been added.
<<lessClover framework can be used standalone as an application run from command line or can be embedded into Your application. Clover.ETL is released under LGPL License.
Clover.ETL is used by many individual developers and several companies, which embeds it into their solutions.
Enhancements:
- The internal transformation language has been improved.
- All reader and writer components support the same set of parameters (dataPolicy, skipFirstLine, skipRows, numRecords, etc.).
- Several new transformation components have been added.
Download (3.1MB)
Added: 2007-07-25 License: LGPL (GNU Lesser General Public License) Price:
824 downloads
XML::XSLT::Wrapper 0.32
XML::XSLT::Wrapper is a consistent interface to XSLT processors. more>>
XML::XSLT::Wrapper is a consistent interface to XSLT processors.
SYNOPSIS
use XML::XSLT::Wrapper;
my $xslt = XML::XSLT::Wrapper->new(
ProcessorList => [libxslt, sablotron],
)
$result = $xslt->transform(
XMLFile => $xml_filename
XSLFile => $xsl_filename
#OR: XMLString => $xml_string
#OR: XSLString => $xsl_string
#OR: xml => $xml_filename_or_string,
#OR: xsl => $xsl_filename_or_string,
XSLParams => { COMEIN => knock knock,
GOAWAY => conk conk },
);
$result = $xslt->transform(
OutFile => $output_filename,
XMLFile => $xml_filename
XSLFile => $xsl_filename
XSLParams => [ COMEIN, knock knock,
GOAWAY, conk conk ],
);
# NB: The pre_parsing interface is likely to change:
%pre_parsed = $xslt->pre_parse(
XSLFile => $xsl_filename
);
$pre_parsed{$processor}{xsl} = $parsed_xsl;
foreach (@xml_files) {
$result = $xslt->transform(
XSLParsed = $parsed_xsl;
OutFile => $output_filename,
XMLFile => $_,
XSLParams => [ COMEIN, knock knock,
GOAWAY, conk conk ],
);
}
See also examples/*.pl, t/*.t and Driver/*.pm in the distribution directory.
Provides a consistent interface to various XSLT processors. Tries each of a supplied list of processors in turn until one performs a successful transform. If no list is given, tries all the processors it knows until one works. Does its best to fail gracefully whenever a processor does not work for some reason.
Can return the result of the transform as a string, or write it to a specified file.
For those processors which can accept parameters to an XSLT stylesheet, XML::XSLT::Wrapper can accept these as hash of name-value pairs, or as an array of [name, value, name, value, ...]
On completion, returns: - if it has written an output file - the result string if it has succeeded but not written an output file - undef if it has failed
Currently knows how to use XML::LibXSLT, XML::Xalan, XML::Sablotron, XML::XSLT as well as the Java processors XT and Saxon. You need to set your CLASSPATH environment variable first for the Java processors, or pass it to the transform in a JavaClassPath hash element. In a future version, there will be a parameter to turn off support for the Java processors. The XML::Sablotron Ive tested with is 0.52.
<<lessSYNOPSIS
use XML::XSLT::Wrapper;
my $xslt = XML::XSLT::Wrapper->new(
ProcessorList => [libxslt, sablotron],
)
$result = $xslt->transform(
XMLFile => $xml_filename
XSLFile => $xsl_filename
#OR: XMLString => $xml_string
#OR: XSLString => $xsl_string
#OR: xml => $xml_filename_or_string,
#OR: xsl => $xsl_filename_or_string,
XSLParams => { COMEIN => knock knock,
GOAWAY => conk conk },
);
$result = $xslt->transform(
OutFile => $output_filename,
XMLFile => $xml_filename
XSLFile => $xsl_filename
XSLParams => [ COMEIN, knock knock,
GOAWAY, conk conk ],
);
# NB: The pre_parsing interface is likely to change:
%pre_parsed = $xslt->pre_parse(
XSLFile => $xsl_filename
);
$pre_parsed{$processor}{xsl} = $parsed_xsl;
foreach (@xml_files) {
$result = $xslt->transform(
XSLParsed = $parsed_xsl;
OutFile => $output_filename,
XMLFile => $_,
XSLParams => [ COMEIN, knock knock,
GOAWAY, conk conk ],
);
}
See also examples/*.pl, t/*.t and Driver/*.pm in the distribution directory.
Provides a consistent interface to various XSLT processors. Tries each of a supplied list of processors in turn until one performs a successful transform. If no list is given, tries all the processors it knows until one works. Does its best to fail gracefully whenever a processor does not work for some reason.
Can return the result of the transform as a string, or write it to a specified file.
For those processors which can accept parameters to an XSLT stylesheet, XML::XSLT::Wrapper can accept these as hash of name-value pairs, or as an array of [name, value, name, value, ...]
On completion, returns: - if it has written an output file - the result string if it has succeeded but not written an output file - undef if it has failed
Currently knows how to use XML::LibXSLT, XML::Xalan, XML::Sablotron, XML::XSLT as well as the Java processors XT and Saxon. You need to set your CLASSPATH environment variable first for the Java processors, or pass it to the transform in a JavaClassPath hash element. In a future version, there will be a parameter to turn off support for the Java processors. The XML::Sablotron Ive tested with is 0.52.
Download (0.010MB)
Added: 2007-06-07 License: Perl Artistic License Price:
872 downloads
Geography::NationalGrid::TW 0.03
Geography::NationalGrid::TW is a Perl module to convert Taiwan Datum (TWD67/TM2, TWD97/TM2) to/from Latitude and Longitude. more>>
Geography::NationalGrid::TW is a Perl module to convert Taiwan Datum (TWD67/TM2, TWD97/TM2) to/from Latitude and Longitude.
SYNOPSIS
You should _create_ the object using the Geography::NationalGrid factory class, but you still need to know the object interface, given below.
# default TWD97
my $point1 = new Geography::NationalGrid::TW(
Easting => 302721.36,
Northing => 2768851.3995,
);
printf("Point 1 is %f X and %f Yn", $point1->easting, $point1->northing);
printf("Point 1 is %f N and %f En", $point1->latitude, $point1->longitude);
# transform to TWD67
$point1->transform(TWD67);
Once created, the object allows you to retrieve information about the point that the object represents. For example you can create an object using easting / northing and the retrieve the latitude / longitude.
<<lessSYNOPSIS
You should _create_ the object using the Geography::NationalGrid factory class, but you still need to know the object interface, given below.
# default TWD97
my $point1 = new Geography::NationalGrid::TW(
Easting => 302721.36,
Northing => 2768851.3995,
);
printf("Point 1 is %f X and %f Yn", $point1->easting, $point1->northing);
printf("Point 1 is %f N and %f En", $point1->latitude, $point1->longitude);
# transform to TWD67
$point1->transform(TWD67);
Once created, the object allows you to retrieve information about the point that the object represents. For example you can create an object using easting / northing and the retrieve the latitude / longitude.
Download (0.005MB)
Added: 2006-08-23 License: Perl Artistic License Price:
1157 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above transform search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
