Free geographical software for linux

OGDI is the Open Geographic Datastore Interface. OGDI is an application programming interface (API) that uses a standardized access methods to work in conjunction with GIS software packages (the application) and various geospatial data products.
OGDI uses a client/server architecture to facilitate the dissemination of geospatial data products over any TCP/IP network, and a driver-oriented approach to facilitate access to several geospatial data products/formats.
Enhancements:
- This release fixes some significant bugs in the VRF (VPF) driver.

Gcal is a program for calculating and printing calendars. It displays hybrid and proleptic Julian and Gregorian calendar sheets, respectively for one month, three months, or a whole year.
It also displays eternal holiday lists for many countries around the globe, and features a very powerful creation of fixed date liststhat can be used for reminding purposes. Gcal can calculate various astronomical data and times of the Sun and the Moon for pleasure at any location, precisely enough for most civil purposes.
Gcal supports some other calendar systems, for example, the Chinese and Japanese calendars, the Hebrew calendar, and the civil Islamic calendar, too.
English user manual included; German user manual included.
Main features:
- Some special calendar sheet formats.
- Calendar sheets can be provided with week numbers.
- Variable number of year calendar sheet blocks.
- Adjustable ordering of displayed dates.
- Adjustable period of Gregorian Reformation.
- Proleptic Julian and Gregorian calendars.
- Adjustable highlighting of holidays and actual day.
- Variable starting day of week.
- Output of day-of-year numbers and concatenated day and day-of-year numbers.
- Allows user-defined ordering of the date elements.
- Output of fiscal years.
- Output of lists or ranges of months or years.
- Sorted output of selectable country/territory specific eternal holiday lists (mostly complete) for nearly *all* countries around the globe, which are generated automatically.
- Sorted output of Christian Western churches calendar holidays, Orthodox Christian Eastern churches old and new calendar holidays, Hebrew calendar holidays, Islamic civil calendar holidays (since AD 622), Persian "Jalaali" calendar holidays, Chinese and Japanese calendar holidays (since AD 1645), more "other" calendar system holidays, multicultural New Years Days, and start of "other" calendar system months, which are also generated automatically.
- Sorted output of fixed date lists which can be defined and created in a highly flexible manner.
- Allows filtration of fixed dates by using regular expressions and other built-in methods.
- Allows the use of date and text variables and basic operations on them.
- Some gimmicks like solar and lunar eclipse time, sunrise/sunset plus a lot of other Sun based data and times, Moon phase, Full and New Moon time, moonrise/moonset plus a lot of other Moon based data and times, zodiacal markers, equinox and solstice, air line distance between two geographic point locations plus course angles, biorhythm et cetera...
- Fixed dates can be stored in several files.
- Nearly unlimited nesting level of include files.
- Nearly unlimited internal text and table lengths.
- Default options can be stored in the `GCAL environment variable.
- Options and commands stored in response files can be preloaded.
- Uses either an external pager or a simple built-in pager.
- Detailed Texinfo reference manual.
- German, English and American program version by default.
- Supports various computer platforms.
- GNU `gettext internationalization technology, which allows the use of message catalogs for most native languages.
- GNU `autoconf(iguration) installation technology.
- Supports both UN*X short-style options and GNU long-style options.

Geo::Spline is a Perl module to calculate geographic locations between GPS fixes.

SYNOPSIS

use Geo::Spline;
my $p0={time=>1160449100.67, #seconds
lat=>39.197807, #degrees
lon=>-77.263510, #degrees
speed=>31.124, #m/s
heading=>144.8300}; #degrees clockwise from North
my $p1={time=>1160449225.66,
lat=>39.167718,
lon=>-77.242278,
speed=>30.615,
heading=>150.5300};
my $spline=Geo::Spline->new($p0, $p1);
my %point=$spline->point(1160449150);
print "Lat:", $point{"lat"}, ", Lon:", $point{"lon"}, "nn";

my @points=$spline->pointlist();
foreach (@points) {
print "Lat:", $_->{"lat"}, ", Lon:", $_->{"lon"}, "n";
}

This program was developed to be able to calculate the position between two GPS fixes using a 2-dimensional 3rd order polynomial spline.

f(t) = A + B(t-t0) + C(t-t0)^2 + D(t-t0)^3 #position in X and Y
f(t) = B + 2C(t-t0) + 3D(t-t0)^2 #velocity in X and Y

I did some simple Math (for an engineer with a math minor) to come up with these formulas to calculate the unknowns from our knowns.

A = x0 # when (t-t0)=0 in f(t)
B = v0 # when (t-t0)=0 in f(t)
C = (x1-A-B(t1-t0)-D(t1-t0)^3)/(t1-t0)^2 # solve for C from f(t)
C = (v1-B-3D(t1-t0)^2)/2(t1-t0) # solve for C from f(t)
D = (v1(t1-t0)+B(t1-t0)-2x1+2A)/(t1-t0)^3 # equate C=C then solve for D

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.

geotool is a small tool that is a collection of some GeoIP.dat quirks.

Inserts countries into output of numerous cmdline network tools reverses GeoIP.dat into a guarding.p2p.

Usage:
geotool [OPTION]... GeoIP.dat

--trace=IP show geological position of IP or domain --trace=- will read (for example) traceroute output from stdin and insert geographic information behind IPs or domains
--reverse[=SKIP] reverse GeoIP.dat into a list of countries with their IP ranges (guarding.p2p); SKIP sets how many IPs should be skipped before the next check
0 will result in the most correct list
256 for slow computers (default)
65536 fastest
--version output version information and exit
--help display this help and exit

Commonly referred to as GRASS, this is a Geographic Information System (GIS) used for geospatial data management and analysis, image processing, graphics/maps production, spatial modeling, and visualization. GRASS is currently used in academic and commercial settings around the world, as well as by many governmental agencies and environmental consulting companies.

GRASS GIS is free software released under the GNU/GPL license.

GeoQO project is a geographical waypoint management software set that lets you manage your geocaches and other types of geographical data.
- geoqo: The command line interface to your data
(this is likely what most people need).
- GeoDB: The perl module interface which geoqo is built on top of.
(Programmers may wish to use these modules too).
Note/Warning: This is a work in progress. There are many more features than are currently documented (Im working on it; be patient). If you have questions, stop by the #geocache IRC chat room and Id be happy to answer questions. Or even better, write the mailing list and I or someone else will help you.
Enhancements:
- Geocaches can be rated and ratings can be sent to and retrieved from a rating server.
- Perl can be directly embedded within scripts.
- The top10 module can do averages as well as call scripts on each result.
- Improved GUI support.
- Other miscellaneous improvements and changes.