to transform
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 321
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
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
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
Xholon runtime framework 0.6
Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. more>>
Xholon runtime framework executes applications that are event-driven or that have highly dynamic structure or behavior. Specify your models using XML and Java, or using third-party UML2 tools and MDA transformations.
To get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.
<<lessTo get started, read or actively work through the basic HelloWorld tutorial. Its a very simple application, but it demonstrates many of the main concepts.
For more detail on the concepts behind Xholon, you might want to read one of the papers thats been published. These describe how to model cells and other complex biological entities using tools designed for developing real-time and embedded systems.
This earlier work used Rational Rose RealTime and C++, rather than the current Java. Xholon is intended to be a runtime framework that can execute the same types of systems described in those papers, plus many more traditional non-biological event-driven systems.
The goal of the Cellontro sister project is to develop complex biological simulations using the Xholon framework. Most of the features described in the published papers have been re-implemented as Cellontro applications using Xholon.
Also have a look at the sample applications that are included with the Xholon software. These give an idea of the range of applications that can be supported by the Xholon runtime framework.
These have been employed as use cases to determine what functionality is most important in Xholon. The digital watch simulation is a good example of a Xholon application with a hierarchical state machine, developed using a UML modeling tool.
A Xholon is essentially a holon. A holon is an entity that lives within a hierarchical structure, and is both a whole and a part at the same time.
In mainstream computer science terms, a Xholon is a node in a tree. The node has a single parent, possibly one or more children, and possibly one or more siblings. A Xholon may also be an active agent able to interact in real-time with other Xholons in the tree.
In UML2 terminology, a Xholon is a structured classifier that may exist as a part within other structured classifiers, and that may in turn contain other structured classifiers as parts of itself. The result is a hierarchical containment structure, nested to an arbitrary number of levels.
As a part, a Xholon plays a specific role within another structured classifier. Xholons are UML classes that are subsequently refined using UML2 composite structure diagrams. Structured classifiers interact with each other through ports, by passing messages or by making function calls.
Using the more philosophical terminology used to describe holons, a Xholon is something that is simultaneously both a whole and a part. Since everything in the universe is a holon, then everything running within a computer application should be a Xholon. The term holon was invented by Arthur Koestler in 1967.
The Xholon Project is inspired by biological concepts. A major incentive behind the project is to build a run-time environment that is equally adapted to running simulations of biological systems, and to running more traditional real-time, embedded and other event-driven reactive systems.
Xholon applications may contain structures that are highly mutable. A Xholon is an active agent that can modify the tree structure in which it lives. It can navigate the tree to interact with any other node, it can add, delete or modify other nodes, it can exchange messages with other nodes, and it can move itself to another position within the tree.
The Xholon Project incorporates many concepts of the Real-time Object-Oriented Modeling (ROOM) methodology, much of which has been incorporated into UML2. At the same time, Xholon removes some of the limitations of ROOM to allow for greater flexibility, mutability and mobility of active objects.
The Xholon run-time can serve as a target for a Model Driven Architecture (MDA) transformation pipeline. MDA stresses the importance of models, and the ability to transform those models, through a series of steps, into an executing target system.
You can create your model using a UML tool such as Gentlewares Poseidon or NoMagics MagicDraw, save the model as an XMI file, transform it using XSLT (or by some other MDA means) into a Xholon model and application, and then execute the model.
Enhancements:
- UML state machine simulation capabilities have been extended, including animation, and fork, join, junction.
- Additional Agent-Based Modeling functionality is available.
- The NetLogo-like syntax has been enhanced.
- The architecture is more flexible and is ready to more fully support integration of multiple domains.
- Histograms and probability distributions are now available. Line charts update in real-time.
- Numerous other modeling, simulation, transformation, and execution features have been added.
Download (3.6MB)
Added: 2007-06-04 License: LGPL (GNU Lesser General Public License) Price:
872 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
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
Text::WagnerFischer 0.04
Text::WagnerFischer is an implementation of the Wagner-Fischer edit distance. more>>
Text::WagnerFischer is an implementation of the Wagner-Fischer edit distance.
SYNOPSIS
use Text::WagnerFischer qw(distance);
print distance("foo","four");# prints "2"
print distance([0,1,2],"foo","four");# prints "3"
my @words=("four","foo","bar");
my @distances=distance("foo",@words);
print "@distances"; # prints "2 0 3"
@distances=distance([0,2,1],"foo",@words);
print "@distances"; # prints "3 0 3"
This module implements the Wagner-Fischer dynamic programming technique, used here to calculate the edit distance of two strings. The edit distance is a measure of the degree of proximity between two strings, based on "edits": the operations of substitutions, deletions or insertions needed to transform the string into the other one (and vice versa). A cost (weight) is needed for every of the operation defined above:
/ a if x=y (cost for letter match)
w(x,y) = | b if x=- or y=- (cost for insertion/deletion operation)
c if x!=y (cost for letter mismatch)
These costs are given through an array reference as first argument of the distance subroutine: [a,b,c]. If the costs are not given, a default array cost is used: [0,1,1] that is the case of the Levenshtein edit distance:
/ 0 if x=y (cost for letter match)
w(x,y) = | 1 if x=- or y=- (cost for insertion/deletion operation)
1 if x!=y (cost for letter mismatch)
This particular distance is the exact number of edit needed to transform the string into the other one (and vice versa). When two strings have distance 0, they are the same. Note that the distance is calculated to reach the _minimum_ cost, i.e. choosing the most economic operation for each edit.
<<lessSYNOPSIS
use Text::WagnerFischer qw(distance);
print distance("foo","four");# prints "2"
print distance([0,1,2],"foo","four");# prints "3"
my @words=("four","foo","bar");
my @distances=distance("foo",@words);
print "@distances"; # prints "2 0 3"
@distances=distance([0,2,1],"foo",@words);
print "@distances"; # prints "3 0 3"
This module implements the Wagner-Fischer dynamic programming technique, used here to calculate the edit distance of two strings. The edit distance is a measure of the degree of proximity between two strings, based on "edits": the operations of substitutions, deletions or insertions needed to transform the string into the other one (and vice versa). A cost (weight) is needed for every of the operation defined above:
/ a if x=y (cost for letter match)
w(x,y) = | b if x=- or y=- (cost for insertion/deletion operation)
c if x!=y (cost for letter mismatch)
These costs are given through an array reference as first argument of the distance subroutine: [a,b,c]. If the costs are not given, a default array cost is used: [0,1,1] that is the case of the Levenshtein edit distance:
/ 0 if x=y (cost for letter match)
w(x,y) = | 1 if x=- or y=- (cost for insertion/deletion operation)
1 if x!=y (cost for letter mismatch)
This particular distance is the exact number of edit needed to transform the string into the other one (and vice versa). When two strings have distance 0, they are the same. Note that the distance is calculated to reach the _minimum_ cost, i.e. choosing the most economic operation for each edit.
Download (0.004MB)
Added: 2007-08-22 License: Perl Artistic License Price:
793 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
Sid parser generator 1.10
Sid is an LL(1) parser generator. more>>
Sid is an LL(1) parser generator. This project can read grammars written in more convenient forms and transform them to LL(1).
The language-specific actions are stored seperately to the grammar, which allows for multiple languages in the future.
Although Sid is intended to be used with lexi an example is included demonstrating use with lex.
Enhancements:
- This is the first release of Sid as a stand-alone project. It has been moved out of the TenDRA compiler.
<<lessThe language-specific actions are stored seperately to the grammar, which allows for multiple languages in the future.
Although Sid is intended to be used with lexi an example is included demonstrating use with lex.
Enhancements:
- This is the first release of Sid as a stand-alone project. It has been moved out of the TenDRA compiler.
Download (0.20MB)
Added: 2007-06-05 License: BSD License Price:
878 downloads
text-vimcolor 0.11
text-vimcolor is a command-line program to syntax color a file in HTML, XML or PDF. more>>
text-vimcolor is a command-line program to syntax color a file in HTML, XML or PDF.
SYNOPSIS
$ text-vimcolor --format html --full-page FILENAME > OUTPUT.html
$ text-vimcolor --format xml FILENAME > OUTPUT.xml
$ text-vimcolor --format pdf FILENAME --output OUTPUT.pdf
This program uses the Vim text editor to highlight text according to its syntax, and turn the highlighting into HTML, XML or PDF output. It works with any file type which Vim itself can highlight. Usually Vim will be able to autodetect the file format based on the filename (and sometimes the contents of the file).
Exactly one filename should be given on the command line to name the input file. If none is given input will instead be read from stdin (the standard input).
If Vim cant guess the file type automatically, it can be specified explicitly using the --filetype option. For example:
$ text-vimcolor --format html --filetype prolog foo.pl > foo.html
This program is a command line interface to the Perl module Text::VimColor.
OPTIONS
The following options are understood:
--help
Show a summary of the usage, including a list of options.
--debug
Turns on debugging in the underlying Perl module. This makes it print the command used to run Vim.
--filetype file-type
Set the type of the file explicitly. The file-type argument should be something which Vim will recognise when set with its filetype option. Examples are perl, cpp (for C++) and sh (for Unix shell scripts). These names are case sensitive, and should usually be all-lowercase.
--format output-format
The output format to generate. Must be one of the following:
html
Generate XHTML output, with text marked with elements with class attributes. A CSS stylesheet should be used to define the coloring, etc., for the output. See the --full-page option below.
xml
Output is in a simple XML vocabulary. This can then be used by other software to do further transformations (e.g., using XSLT).
pdf
XML output is generated and fed to the FOP XSL-FO processor, with an appropriate XSL style sheet. The stylesheet uses XSLT to transform the normal XML output into XSL-FO, which is then rendered to PDF. For this to work, the command fop must be available. An output file must be specified with --output with this format.
Full details of the HTML and XML output formats can be found in the documentation for Text::VimColor.
--output output-filename
Specifies the name of the output file (which will end up containing either HTML, XML or PDF). If this option is omitted, the output will be sent to stdout (the standard output). This option is required when the output format is PDF (because of limitations in FOP).
--full-page
When the output format is HTML, this option will make the output a complete HTML page, rather than just a fragment of HTML. A CSS stylesheet will be inserted inline into the output, so the output will be useable as it is.
--no-inline-stylesheet
When the output format is HTML and --fullpage is given, a stylesheet is normally inserted in-line in the output file. If this option is given it will instead be referenced with a element.
--let name=value
When Vim is run the value of name will be set to value using Vims let command. More than one of these options can be set. The value is not quoted or escaped in any way, so it can be an expression. These settings take precedence over --unlet options.
This option corresponds to the vim_let setting and method in the Perl module.
--unlet name
Prevent the value of name being set with Vims let command. This can be used to turn off default settings.
This option corresponds to the vim_let setting and method in the Perl module, when used with a value of undef.
<<lessSYNOPSIS
$ text-vimcolor --format html --full-page FILENAME > OUTPUT.html
$ text-vimcolor --format xml FILENAME > OUTPUT.xml
$ text-vimcolor --format pdf FILENAME --output OUTPUT.pdf
This program uses the Vim text editor to highlight text according to its syntax, and turn the highlighting into HTML, XML or PDF output. It works with any file type which Vim itself can highlight. Usually Vim will be able to autodetect the file format based on the filename (and sometimes the contents of the file).
Exactly one filename should be given on the command line to name the input file. If none is given input will instead be read from stdin (the standard input).
If Vim cant guess the file type automatically, it can be specified explicitly using the --filetype option. For example:
$ text-vimcolor --format html --filetype prolog foo.pl > foo.html
This program is a command line interface to the Perl module Text::VimColor.
OPTIONS
The following options are understood:
--help
Show a summary of the usage, including a list of options.
--debug
Turns on debugging in the underlying Perl module. This makes it print the command used to run Vim.
--filetype file-type
Set the type of the file explicitly. The file-type argument should be something which Vim will recognise when set with its filetype option. Examples are perl, cpp (for C++) and sh (for Unix shell scripts). These names are case sensitive, and should usually be all-lowercase.
--format output-format
The output format to generate. Must be one of the following:
html
Generate XHTML output, with text marked with elements with class attributes. A CSS stylesheet should be used to define the coloring, etc., for the output. See the --full-page option below.
xml
Output is in a simple XML vocabulary. This can then be used by other software to do further transformations (e.g., using XSLT).
XML output is generated and fed to the FOP XSL-FO processor, with an appropriate XSL style sheet. The stylesheet uses XSLT to transform the normal XML output into XSL-FO, which is then rendered to PDF. For this to work, the command fop must be available. An output file must be specified with --output with this format.
Full details of the HTML and XML output formats can be found in the documentation for Text::VimColor.
--output output-filename
Specifies the name of the output file (which will end up containing either HTML, XML or PDF). If this option is omitted, the output will be sent to stdout (the standard output). This option is required when the output format is PDF (because of limitations in FOP).
--full-page
When the output format is HTML, this option will make the output a complete HTML page, rather than just a fragment of HTML. A CSS stylesheet will be inserted inline into the output, so the output will be useable as it is.
--no-inline-stylesheet
When the output format is HTML and --fullpage is given, a stylesheet is normally inserted in-line in the output file. If this option is given it will instead be referenced with a element.
--let name=value
When Vim is run the value of name will be set to value using Vims let command. More than one of these options can be set. The value is not quoted or escaped in any way, so it can be an expression. These settings take precedence over --unlet options.
This option corresponds to the vim_let setting and method in the Perl module.
--unlet name
Prevent the value of name being set with Vims let command. This can be used to turn off default settings.
This option corresponds to the vim_let setting and method in the Perl module, when used with a value of undef.
Download (0.020MB)
Added: 2007-05-31 License: Perl Artistic License Price:
876 downloads
Combean 0.1
Combean project is a Java framework for combinatorial structures like graphs or linear programs. more>>
Combean project is a Java framework for combinatorial structures like graphs or linear programs and optimization algorithms working with these structures.
The objective of Combean is to integrate existing proven optimization packages as well as new implementations through a set of lean Java interfaces. Using a JavaBeans-based configuration mechanism, solvers for real-world optimization problems can be generated by plugging together the best-performing components.
Combean as glue between optimization packages leads to more interoperable, adaptable and flexible solutions.
Main features:
- You develop software that uses optimization technology. You would like to use existing optimization codes and you are looking for a possibility to easily integrate your code with them. You want to be flexible to exchange one solver with another as your project moves forward.
- You have written a library that provides data structures or algorithms for optimization problems (combinatorial optimization or mathematical programming). Now you are searching for a way to integrate your library with other existing frameworks and to improve the interoperability of your library.
- You want to use linear programming to solve a real world application and you would like to transform your optimization problem into a linear programming model that is easy to use and compatible with many existing solvers (both open source and commercial).
- You are teaching optimization algorithms and you are searching for a programming framework which integrates standard data structures and algorithms and a way that captures the essence of the optimization problem and results in clear code.
<<lessThe objective of Combean is to integrate existing proven optimization packages as well as new implementations through a set of lean Java interfaces. Using a JavaBeans-based configuration mechanism, solvers for real-world optimization problems can be generated by plugging together the best-performing components.
Combean as glue between optimization packages leads to more interoperable, adaptable and flexible solutions.
Main features:
- You develop software that uses optimization technology. You would like to use existing optimization codes and you are looking for a possibility to easily integrate your code with them. You want to be flexible to exchange one solver with another as your project moves forward.
- You have written a library that provides data structures or algorithms for optimization problems (combinatorial optimization or mathematical programming). Now you are searching for a way to integrate your library with other existing frameworks and to improve the interoperability of your library.
- You want to use linear programming to solve a real world application and you would like to transform your optimization problem into a linear programming model that is easy to use and compatible with many existing solvers (both open source and commercial).
- You are teaching optimization algorithms and you are searching for a programming framework which integrates standard data structures and algorithms and a way that captures the essence of the optimization problem and results in clear code.
Download (1.8MB)
Added: 2006-09-05 License: GPL (GNU General Public License) Price:
1145 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 to 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
