Java Implementation of the Base26GPS Standard

avi shaby

4.00/5 (1 vote)

Jul 21, 2013

CPOL

4 min read

12951

This tip describes the Java implementation of Base26GPS.

Introduction

The Base26GPS standard is used for sharing location between platforms by converting the longitude and latitude to a string. The string is from A to Z, having 26 characters all together thus making it a Base26 in the numeral system which is also known as Hexavigesimal. In this tip, I will describe the code that is used to implement it. This code can be used as the driver for an Android based application that uses Base26GPS.

For more information, you can visit the website here.

Background

Location is based on Longitude and Latitude. Longitude is a number between -180.0 to 180 and latitude is a number between -90 to 90. Until now, applications from different platforms did not have a standard to send the location between one another, they used their own internal standards. It has a small resemblance to the time before XML and after XML.

Using the Code

There are two classes:

LocToBase26GPS - converts Longitude and Latitude to a string
Base26GPSToLoc - converts a string to Longitude and Latitude

Converting from Longitude and Latitude to alphabetic letters is done using the following steps:

The first three letters are "GPS", next six letters represent Longitude and last six letters represent Latitude. All together fifteen letters.
The Longitude and Latitude should always have 4 numbers after the dot. For example: -180 will be -180.0000, 12.53 will be 12.5300 and 151.45319 will be 151.4532
Each one is separated to the number located at the left side of the decimal point and the number located at the right of the decimal point.
The left number is from -180 to 180 for Longitude. -180 equals to AA and 180 equals to NW. Here the counting begins from -180.
For Latitude, the left number is from -90 to 90. -90 equals to AA and 90 equals to GY. Here the counting begins from -90.
The right number is divided into two groups. Each group is from 00 to 99. 00 equals to AA and 99 equals to DV. Here the counting begins from 0.
After conversion, there are six letters for Longitude and six letters for Latitude.
For example – Longitude of 12.45 and Latitude of -11.54 will generate the string
"GPSHKBTAADBCCAA".

Converting from alphabetic letters to Longitude and Latitude is done using the same principle.

Here is the code for the LocToBase26GPS class:

public class LocToBase26GPS { 
 /* ====================================================================
  * Class Name : LocToBase26GPS
  * Class Activity : Convert Location to Base26GPS
  =====================================================================*/
 private String base26GPSString; 
 private float longitude;
 private float latitude;
 private String faultMessage;
 private boolean isFault;

Return the translated string:

 public String Base26GPSString() {
  return base26GPSString;  
}

Return the fault message:

public String FaultMessage() {
  return faultMessage;
}

Return the fault flag:

public boolean IsFault() {
  return isFault;
}

Constructor:

public LocToBase26GPS() {}

Send the longitude and latitude to be translated to string:

public void LocToBase26GPSTranslate(float Longitude,float Latitude) {
  /* ====================================================================== 
  * public function
  * function name : LocToBase26GPSTranslate                                  
  * function activity : convert Longitude and Latitude parameter to string 
  *                    according to Base26GPS standard
  * input parameters : float Longitude - the Longitude to be translated
  *                    float Latitude - the Latitude to be translated 
  *  ======================================================================= */
   
  longitude = Longitude;
  latitude = Latitude;
  String LongitudeString = "";
  String LatitudeString = "";
 
  base26GPSString = "";
  faultMessage = "";
  isFault = false;

Generate the Longitude part string:

LongitudeString = LongitudeToBase26GPS(longitude);
if (isFault)
 return;

Generate the Latitude part string:

LatitudeString = LatitudeToBase26GPS(latitude);
if (isFault)
 return;

Attach the "GPS" header:

base26GPSString = "GPS" + LongitudeString + LatitudeString;  
         
    }

Convert Longitude to string:

private String LongitudeToBase26GPS(float longitude) {
  /* ====================================================================== 
  * private function
  * function name : LongitudeToBase26GPS                                  
  * function activity : convert Longitude parameter to string 
  *                    according to Base26GPS standard
  * input parameters : float Longitude - the Longitude to be translated                      
  *  ======================================================================= */
  
     float TempFloat;
     double FractPart;
     double TempFractPart;
     double IntPart;
     int Multiply;
     int Add;
     int Sign;
     String ReturnString = "";

Check the limits of the longitude:

if (longitude < -180 || longitude > 180)
{
 faultMessage = "Longitude Parameter out of limits";
 isFault = true;
 return ReturnString;
}
if (longitude < 0)
{
 longitude -= (float)0.00005;
 Sign = -1;
}
else
{
 longitude += (float)0.00005;
 Sign = 1;
}

Get the integral part:

IntPart = ((double)Math.floor(Math.abs(longitude)))*Sign;

Get the fract part:

FractPart = Math.abs(((double)longitude - IntPart)*10000);

Get the base26 multiply part of the int part. the start is from -180:

   TempFloat = (float)((((int)(IntPart) + 180) / 26));
         Multiply = (int)TempFloat + 65;

If the Longitude is between -0.9999 to -0.0001, use the letter Z:

if ((int)longitude == 0 && Sign == -1)
             Multiply = 90;