Free oziexplorer gps software for linux

PloneWorldKit project is an out-of-the-box GIS for the Web.
PloneWorldKit is a mapping solution for ZOPE Plone.
It is built around the worldkit engine and makes annotating fairly easy.
worldKit is an easy to use and flexible mapping application for the Web (a lightweight GIS). Its a SWF-based app, configured by XML, and with data fed by RSS.
Main features:
- Ubiquitous use in the Flash Player and with RSS feeds.
- Highly configurable look and feel. Can use images for marking annotations.
- Integrates with weblogging tools, and any software producing RSS.
- Annotations updated in the background, live.
- Displays photos within the map.
- Zoom & Pan. Integrates with Zoomify for high resolution images.
- Accepts input for Collaborative Cartography.
- Annotations are categorizable. Javascript interface for GIS layer functionality.
- Connects annotations for GPS track routes.
- ntegration of worldKit as a content type (Map)
- Complete TTW (Through The Web) configuration of worldKit attributes
- ZCatalog based XML and RSS generation (config.xml, rss.xml)
- 3 annotation content types (Node, Line, Polygon)
- Base classes for content type developers
- Categorization of annotations TTW
- Time Navigation out of the box using "modified" index

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

phpExifRW provides an Exif reader & writer.
vinSMSIndia is a simple PHP class that allows you to send free SMS messages to Indian mobile users.
Main features:
- Read Exif Information
- Extract and display emdedded thumbnails
- Add Comments to files.
- Transfering EXIF information from one file to another.
Enhancements:
- Better code. Cleaner several un-wanted code.
- Added several additional tags that show GPS information.
- Fixed Shutter Speed value calculation
- Fixed Aperture value calculation
- Fixed Special characters in Make & Model
- Support for following Cameras added:
- OLYMPUS OPTICAL CO.,LTD -> C3000Z
- NIKON D2H
- Canon 300D

802.11b Network Discovery Tools is a gtk tool to scan for 802.11b networks using wavelan/aironet hardware and Linux wireless extensions. It includes the ability to log coordinates of found networks from a GPS device that is NMEA-compatible, and can be linked to a serial port.

It currently logs the WAP MAC to a database, along with the frequency the AP uses and link quality info. aside from that, you can also connect a Garmin GPS receiver and snarf that data. Im just using GPS::Garmin, which currently doesnt support NMEA, and i didnt feel like writing another NMEA library, so maybe ill do that later. for now, youll have to
have your GPS receiver sending data in GRMN/GRMN.

To install the program, you should just have to run "make install" as root.

Just run perlskan, or /usr/local/bin/perlskan *** AS ROOT ***

ive included a small perl program called "catdb" thatll just print the contents of the database in very hard-to-read format.

To examine the db further, you can either write a program to use the PSkan::DB module to examine the database (very simple, its just a Tie::Hash module). to iterate through the database, all you have to do is:

tie(%foo, PSkan::DB);
while(($key, $data) = each %foo) {
...
}
untie(%foo);

it doesnt get much easier.

The "Open Device Monitoring and Tracking Protocol", otherwise known as OpenDMTP, is a protocol and framework that allows bi-directional data communications between servers and devices (clients) over the Internet and similar networks.
OpenDMTP is a highly configurable and extensible protocol for communicating with mobile devices.
OpenDMTP is particularly geared towards Location-based information (LBS) such as GPS, as well as temperature and other data collected in remote-monitoring devices. OpenDMTP is small, and is especially suited for micro-devices such as PDAs, mobile phones, and custom OEM devices.
We saw a need for a communications protocol that allowed high-latency, low-bandwidth (HL/LB) devices to transmit location data to monitoring-systems. Because these devices often have limited network connectivity, the protocol needed to be small and efficient. Example devices include mobile phones, PDAs, OEM micro-devices (alarm systems, temperature monitors, etc.), and more.
There are many mobile GPS tracking devices on the market today with their own closed proprietary protocols. Searching the web for open protocols revealed only a few available for transferring data (including GPS information) between devices. However these solutions are generally designed for non-mobile applications and/or lack some of the low-bandwidth, configurable, and extensible features that mobile applications require.
Main features:
- Small Footprint: Mobile devices typically have limited resources on which to run client code (ie. memory, processor speed). An open protocol designed with this in mind should be optimized to allow efficient implementation and should easily support devices such as PDAs, mobile phones, GPS monitoring devices, and other OEM micro-devices.
- Network Efficient: Mobile devices typically have limited network connectivity, and in some cases data communication can be quite expensive (e.g. satellite). Because of this the protocol needs to be efficient in its dialog between the client and server. The communication needs to be optimized such that the necessary information can be conveyed with a minimum number of bytes in the least amount of time.
- Bi-directional: Some devices can support two-way communication (ie. GPRS, or other socket based connections), while others may only support one-way communication (ie. some satellite communication systems). With this in mind, a protocol should be designed to support both duplex (two-way) and simplex (one-way) communication.
- Transport Media: Differrent mobile applications will have their own unique way of communicating data back to the server. Some may use GPRS, or socket based communication, others may use satellite communication, while still others may use other forms of wireless communication, such as BlueTooth. The design of the protocol should be able to encompass all such transport media types, regardless of the type of transport in use.
- Flexible Data Encoding: Most types of transport media allow for the transmission of binary encoded data. However, there may be some forms of media for which an ASCII encoded data packet is much better suited. A protocol designed with this in mind should be able to support both types of data encoding.
- Configurable Messages: Due to the broad range of data types used in mobile applications, the protocol should be flexible enough to define standard messages, yet still allow custom messages within the framework.
- Extensible: Not every mobile application is the same. Some require special handling and may have various types of inputs and outputs. A protocol designed for mobile applications should insure that the framework can be easily extended to incapsulate the specific needs of the device.
- Industry Compatibility: Having an open protocol insures better compatibility between different client devices and service providers.
- Reference Implementation: Having a reference implementation that showcases the major features of the protocol provides an easy starting point on which developers can add their own features and platform specific implementation without having to worry about how data gets from the client to the server.
OpenDMTP was specifically designed to suit all these needs, especially "Small Footprint" and "Network Efficiency". The typical data plan for GPRS communication, for instance, is usually 1Mb per month. OpenDMTP was designed to optimize packet encoding to allow the collection of GPS information packets once every 3 minutes, 24 hours a day, 30 days a month, and still stay under the 1Mb data plan limit.
While XML is very extensible, it fails the "Small Footprint" and "Network Efficiency" requirements. Thus, it was discounted as a viable protocol solution. Many mobile devices do not have the resources necessary to be able to provide full XML parsing functionality. And an XML packet may need to be several hundred bytes in length just to send a few bytes of actual data. This alone would make the solution cost prohibitive for high-cost transport media such as satellite.
OpenDMTP also includes a full-featured commercial quality reference implementation to jump-start development.
Enhancements:
- NEW: Minor optimizations made to message logging.
- FIX: Log file now properly displays account/device on client connection.

Flight Navigation Planner project is a tool for making flight plans based on known airports.

Flight Navigation Planner lets you make flight plans based on known airports, navaids, fixes, or cities.

You can use the sectional charts, wacs, or the vector/terrain planning charts.

It calculates headings, winds, time, and fuel. It features Airways-based Auto-Routing, Climb and Descent calculations (a/c type based), Fuel Stop Planning, Auto-Route around MOAS and Restricted Airspace, Hi-Res Weather Radar Overlay, Viewing of current sectional, wac, and IFR charts, the ability to see a route over TFRs, detailed nexrad radar overlays over your routes, Terrain Profiles with cloud ceilings, and the ability to upload flight plans to GPS.

DateTime::Precise can perform common time and date operations with additional GPS operations.

SYNOPSIS

use DateTime::Precise;

use DateTime::Precise qw(:TimeVars);

# Constructors and ways to set time.
$t1 = DateTime::Precise->new;
$t2 = DateTime::Precise->new(1998. 4. 3 12:13:44.054);
$t3 = DateTime::Precise->new(time() - 100.23456);
$t4 = DateTime::Precise->new(1998.04.24);
$t1->set_localtime_from_epoch_time;
$t1->set_gmtime_from_epoch_time(time + 120.987);
$t1->set_from_datetime(1998.03.23 16:58:14.65);
$t1->set_time(YDHMS, 1998, 177, 9, 15, 26.5);

# This is the same as $d3->set_from_datetime(...)
$t3->dscanf("%^Y.%M.%D %h:%m:%s", "1998.03.25 20:25:23");
if ($msg = $d1->dscanf("%~M", $input)) {
print "error: $msgn";
print "Must enter a three-letter month abbrev.n";
}

# Get different parts of the time.
$year = $t3->year;
$month = $t3->month;
$day = $t3->day;
$hours = $t3->hours;
$minutes = $t3->minutes;
$seconds = $t3->seconds;
($year, $day_of_year) = $t3->get_time(Yj);

# Print times and dates.
print $t2->asctime;
print $t2->strftime(%T %C%n);
print $t2->dprintf("%^Y.%M.%D %h:%m:%s"); # datetime
print $t2->dprintf("%~w %~M %-D %h:%m:%s CST %^Y"); # ctime

# Copy times.
my $t4 = $t2->copy;

# Set one time object to the same time as another: set $t3 equal to $t2.
$t3->clone($t2);

# Find the difference between two times.
$secs_from_midnight = $t4 - $t1;
$secs_from_midnight = $t4->diff($t1);

# Add seconds, days, months, etc to time.
$t1 = $t4 + 3600; # $t1 is now an hour after midnight
$t1->inc_month(2); # add two months to $t1
$t1->floor_month; # set $t1 to the first of the month
$t1 -= 0.25; # subtract 1/4 of a second from $t1

# Can compare and sort DateTime::Precise.
print "Its late!!!" if ($t1 > $t4);
@sorted = sort @birthdays; # normal comparisons work fine

# Get the GPS weeks, seconds and day.
$gps_week = $t1->gps_week;
$gps_seconds = $t1->gps_seconds;
$gps_day = $t1->gps_day;
($gps_week, $gps_seconds, $gps_day) = $t1->gps_week_seconds_day;