Free distance software for linux

Geo::Distance is a Perl module that can calculate distances and closest locations.

SYNOPSIS

use Geo::Distance;
my $geo = new Geo::Distance;
$geo->formula(hsin);
$geo->reg_unit( toad_hop, 200120 );
$geo->reg_unit( frog_hop => 6 => toad_hop );
my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );
my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This perl library aims to provide as many tools to make it as simple as possible to calculate distances between geographic points, and anything that can be derived from that. Currently there is support for finding the closest locations within a specified distance, to find the closest number of points to a specified point, and to do basic point-to-point distance calculations.

METHODS

new

my $geo = new Geo::Distance;
my $geo = new Geo::Distance( no_units=>1 );

Returns a blessed Geo::Distance object. The new constructor accepts one optional argument.

no_units - Whether or not to load the default units. Defaults to 0 (false).
kilometer, kilometre, meter, metre, centimeter, centimetre, millimeter,
millimetre, yard, foot, inch, light second, mile, nautical mile,
poppy seed, barleycorn, rod, pole, perch, chain, furlong, league,
fathom

formula

if($geo->formula eq hsin){ ... }
$geo->formula(cos);

Allows you to retrieve and set the formula that is currently being used to calculate distances. The availabel formulas are hsin, polar, cos, and mt. hsin is the default and mt/cos are depreciated in favor of hsin. polar should be used when calculating coordinates near the poles.

reg_unit
$geo->reg_unit( $radius, $key );
$geo->reg_unit( $key1 => $key2 );
$geo->reg_unit( $count1, $key1 => $key2 );
$geo->reg_unit( $key1 => $count2, $key2 );
$geo->reg_unit( $count1, $key1 => $count2, $key2 );

This method is used to create custom unit types. There are several ways of calling it, depending on if you are defining the unit from scratch, or if you are basing it off of an existing unit (such as saying 12 inches = 1 foot ). When defining a unit from scratch you pass the name and rho (radius of the earth in that unit) value.

So, if you wanted to do your calculations in human adult steps you would have to have an average human adult walk from the crust of the earth to the core (ignore the fact that this is impossible). So, assuming we did this and we came up with 43,200 steps, youd do something like the following.

# Define adult step unit.
$geo->reg_unit( 43200, adult step );
# This can be read as "It takes 43,200 adult_steps to walk the radius of the earth".

Now, if you also wanted to do distances in baby steps you might think "well, now I gotta get a baby to walk to the center of the earth". But, you dont have to! If you do some research youll find (no research was actually conducted) that there are, on average, 4.7 baby steps in each adult step.

# Define baby step unit.
$geo->reg_unit( 4.7, baby step => adult step );
# This can be read as "4.7 baby steps is the same as one adult step".

And if we were doing this in reverse and already had the baby step unit but not the adult step, you would still use the exact same syntax as above.
distance

my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );

Calculates the distance between two lon/lat points.
closest

my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This method finds the closest locations within a certain distance and returns an array reference with a hash for each location matched.

The closest method requires the following arguments:

dbh - a DBI database handle
table - a table within dbh that contains the locations to search
lon - the longitude of the center point
lat - the latitude of the center point
unit - the unit of measurement to use, such as "meter"
distance - the distance, in units, from the center point to find locations

The following arguments are optional:

lon_field - the name of the field in the table that contains the longitude, defaults to "lon"
lat_field - the name of the field in the table that contains the latitude, defaults to "lat"
fields - an array reference of extra field names that you would like returned with each location
where - additional rules for the where clause of the sql
bind - an array reference of bind variables to go with the placeholders in where
sort - whether to sort the locations by their distance, making the closest location the first returned
count - return at most these number of locations (implies sort => 1)

This method uses some very simplistic calculations to SQL select out of the dbh. This means that the SQL should work fine on almost any database (only tested on MySQL and SQLite so far) and this also means that it is fast. Once this sub set of locations has been retrieved then more precise calculations are made to narrow down the result set. Remember, though, that the farther out your distance is, and the more locations in the table, the slower your searches will be.

GIS::Distance::Vincenty Perl module contains Thaddeus Vincenty distance calculations.

SYNOPSIS

my $calc = GIS::Distance::Vincenty->new();
my $distance = $calc->distance( $lon1, $lat1 => $lon2, $lat2 );

For the benefit of the terminally obsessive (as well as the genuinely needy), Thaddeus Vincenty devised formulae for calculating geodesic distances between a pair of latitude/longitude points on the earths surface, using an accurate ellipsoidal model of the earth.

Vincentys formula is accurate to within 0.5mm, or 0.000015", on the ellipsoid being used. Calculations based on a spherical model, such as the (much simpler) Haversine, are accurate to around 0.3% (which is still good enough for most purposes, of course).

Note: the accuracy quoted by Vincenty applies to the theoretical ellipsoid being used, which will differ (to varying degree) from the real earth geoid. If you happen to be located in Colorado, 2km above msl, distances will be 0.03% greater. In the UK, if you measure the distance from Lands End to John O Groats using WGS-84, it will be 28m - 0.003% - greater than using the Airy ellipsoid, which provides a better fit for the UK.

NOTE: This formula is still considered alpha quality in GIS::Distance. It has not been tested enough to be used in production.

FORMULA

a, b = major & minor semiaxes of the ellipsoid
f = flattening (a-b)/a
L = lon2 - lon1
u1 = atan((1-f) * tan(lat1))
u2 = atan((1-f) * tan(lat2))
sin_u1 = sin(u1)
cos_u1 = cos(u1)
sin_u2 = sin(u2)
cos_u2 = cos(u2)
lambda = L
lambda_pi = 2PI
while abs(lambda-lambda_pi) > 1e-12
sin_lambda = sin(lambda)
cos_lambda = cos(lambda)
sin_sigma = sqrt((cos_u2 * sin_lambda) * (cos_u2*sin_lambda) +
(cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda) * (cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda))
cos_sigma = sin_u1*sin_u2 + cos_u1*cos_u2*cos_lambda
sigma = atan2(sin_sigma, cos_sigma)
alpha = asin(cos_u1 * cos_u2 * sin_lambda / sin_sigma)
cos_sq_alpha = cos(alpha) * cos(alpha)
cos2sigma_m = cos_sigma - 2*sin_u1*sin_u2/cos_sq_alpha
cc = f/16*cos_sq_alpha*(4+f*(4-3*cos_sq_alpha))
lambda_pi = lambda
lambda = L + (1-cc) * f * sin(alpha) *
(sigma + cc*sin_sigma*(cos2sigma_m+cc*cos_sigma*(-1+2*cos2sigma_m*cos2sigma_m)))
}
usq = cos_sq_alpha*(a*a-b*b)/(b*b);
aa = 1 + usq/16384*(4096+usq*(-768+usq*(320-175*usq)))
bb = usq/1024 * (256+usq*(-128+usq*(74-47*usq)))
delta_sigma = bb*sin_sigma*(cos2sigma_m+bb/4*(cos_sigma*(-1+2*cos2sigma_m*cos2sigma_m)-
bb/6*cos2sigma_m*(-3+4*sin_sigma*sin_sigma)*(-3+4*cos2sigma_m*cos2sigma_m)))
c = b*aa*(sigma-delta_sigma)

Bio::Tree::DistanceFactory is a Perl module to construct a tree using distance based methods.

SYNOPSIS

use Bio::Tree::DistanceFactory;
use Bio::AlignIO;
use Bio::Align::DNAStatistics;
my $tfactory = Bio::Tree::DistanceFactory->new(-method => "NJ");
my $stats = Bio::Align::DNAStatistics->new();

my $alnin = Bio::AlignIO->new(-format => clustalw,
-file => file.aln);
my $aln = $alnin->next_aln;
# Of course matrix can come from a different place
# like PHYLIP if you prefer, Bio::Matrix::IO should be able
# to parse many things
my $jcmatrix = $stats->distance(-align => $aln,
-method => Jukes-Cantor);
my $tree = $tfactory->make_tree($jcmatrix);

This is a factory which will construct a phylogenetic tree based on the pairwise sequence distances for a set of sequences. Currently UPGMA (Sokal and Michener 1958) and NJ (Saitou and Nei 1987) tree construction methods are implemented.

Tk::PerlInheritanceTree is a Perl module that displays a graphical representation of the inheritance tree for a given class-name.

SYNOPSIS

require Tk::PerlInheritanceTree;
...
my $inheritance_tree = $main_window->PerlInheritanceTree()->pack;

$inheritance_tree->classname(Tk::MainWindow);

Tk::PerlInheritanceTree displays a graphical representation of the inheritance tree for a given class(package)-name. The nodes representing classnames have mouseclick bindings to open a Tk::PerlMethodList - widget. Tk::PerlInheritanceTree is a Tk::Frame-derived widget.

PerlInheritanceTree.pm can be run as stand-alone application.

METHODS

Tk::PerlInheritanceTree supports the following methods:

classname(A::Classname)

Set the Classname-Entry to A::Classname and show_classtree.

show_classtree()

Display a tree for the given classname

OPTIONS

Tk::PerlInheritanceTree supports the following options:

-classname

configure(-classname=>A::Classname) same as method classname()

-gridsize

configure(-gridsize=>$size) Set the distance between nodes to $size pixels. Defaults to 100.

-multiple_methodlists

configure(-multiple_methodlists=>bool) Allows multiple instances of PerlMethodList to be opened if set to a true value. Defaults to 0.

Snake is an experimental algorithm for exchanging information in a dynamic growing network, where a sender and receiver must stay synchronized despite the changing distance. snake5 is a communication algorithm for exchanging information between nodes in a dynamic changing network
Settings:
- Update speed and frequency
- Listen to a node in the signal mode
- Sliders changing appearance in the topology mode
- Stretch folding animation (YES/NO)
- Draw lines between the nodes (YES/NO)
- Makes the nodes twiddle (visualize data in a node)
Press t to switch to the signal mode. You see the wavelet table over time from octave 0 (top) to octave 11 (bottom). The red signal indicates the current folding-distance (odist).
Wait until the signals in all the different octaves (vertical) become stable and repetitive. At that point the system has learned the pattern.
Now increase the distance of sender and receiver using folding (+ and -). The signal stays stable, despite the increased distance (*). If the signal quality should degrade then decrease the distance again by folding or wait until the system stabilizes itself.

iScholar project is a content-neutral authoring and publishing system that can be used to write on-line or paper & pen exams and course pages on virtually any topic.
iScholar is ideally suited to deliver or supplement the courses and curriculum of
- Professional Training Programs
- Corporate Training Programs
- Distance Education and Continuing Education
- University Courses
- Grade School or High School Classes
Main features:
Standard Features
- WYSIWYG interface for creating and editing exams
- Print feature lets you print pen & paper versions of on-line exams
Supports many question types including:
- multiple choice, multiple answer, true/false, drop-down
- Fill in the blank, Essay, Number Check, Range Check,
- Expression Check, Function Check
Other Features
- Automated marking
- Hints & Hint Penalties
- Multiple Attempts & Attempt penalties
- Timed Exams
- Test and Exam Certifications
- Questions can include images and audio/video elements.
- Question content can be written in HTML, LaTeX (for equations and math symbols) or plain Text
- Grouping of exams and course pages into modules with prerequisites and anti-requisites

StepStats is a smart and simple application that allows you to keep track of your sport successes. The application is perfectly suitable for all sports, where you want to create stats on distance, time or speed.
Main features:
- simple, understandable interface
- keeps track of date, distance, steps and time
- gives you stats with overall values and a nice graph with your speed
- automatic backup of your data once a week to prevent data loss or corruption
- available for MacOS X, Windows and Linux
- and best of all - It is Freeware

Xplanet was inspired by Xearth, which renders an image of the earth into the X root window. All of the major planets and most satellites can be drawn, similar to the Solar System Simulator.
A number of different map projections are also supported, including azimuthal, Lambert, Mercator, Mollweide, orthographic, and rectangular.
Enhancements:
- Added the -grs_longitude option, to specify the longitude of Jupiters Great Red Spot, in System II coordinates. This assumes the Jupiter image has the center of the Great Red Spot at pixel 0 (at the left side of the image) in order to draw it at the right position.
- Added the Icosagnomonic projection, contributed by Ian Turner.
- Fixed a bug where output filenames had an extra digit in some cases.
- Added the bump_map and bump_scale options in the configuration file.
- Added the -glare option to set the size of the suns glare.
- An image map may be specified for the sun in the configuration file now. A shade value is now required for the sun (should be 100, otherwise the sun will have a night side!)
- Added the -arc_spacing option to set the default angular distance between great arc points. It used to be 0.1 degree, so arcs smaller than this wouldnt get drawn.
- Fixed a bug where markers were not aligned properly when using align = "above" or "below".
- Added warnings if options are specified in the [default] section of the configuration file that probably shouldnt be there.