Lat Long to Minutes and Seconds?

Converting Latitude and Longitude to Degrees, Minutes, and Seconds (DMS)

Learn how to convert decimal latitude and longitude coordinates into the Degrees, Minutes, Seconds (DMS) format, a common representation in navigation and cartography.

Latitude and longitude are fundamental for pinpointing locations on Earth. While decimal degrees (DD) are widely used in digital systems due to their simplicity in calculations, the Degrees, Minutes, Seconds (DMS) format remains prevalent in traditional navigation, surveying, and some mapping contexts. Understanding how to convert between these formats is a crucial skill for anyone working with geospatial data.

Understanding Decimal Degrees (DD) and DMS

Before diving into the conversion process, let's clarify what each format represents:

• Decimal Degrees (DD): This is a single number representing the angular distance from the equator (for latitude) or the Prime Meridian (for longitude). Positive values typically indicate North latitude or East longitude, while negative values indicate South latitude or West longitude.

• Degrees, Minutes, Seconds (DMS): This format breaks down the angular measurement into three parts:

  • Degrees (°): The whole number part of the coordinate.
  • Minutes ('): Each degree is divided into 60 minutes. This is the whole number part of the fractional degree multiplied by 60.
  • Seconds ("): Each minute is divided into 60 seconds. This is the fractional part of the minutes multiplied by 60. Seconds can often be expressed with decimal precision.

flowchart TD
    A[Decimal Degree] --> B{"Separate Integer and Fractional Parts"}
    B --> C[Integer Part = Degrees]
    B --> D[Fractional Part]
    D --> E{"Multiply Fractional Part by 60"}
    E --> F{"Separate Integer and Fractional Parts"}
    F --> G[Integer Part = Minutes]
    F --> H[Fractional Part]
    H --> I{"Multiply Fractional Part by 60"}
    I --> J[Result = Seconds]
    J --> K[Combine: Degrees° Minutes' Seconds'']

Flowchart illustrating the conversion process from Decimal Degrees to DMS.

The Conversion Algorithm

The conversion from decimal degrees to DMS involves a series of steps for both the degrees and the fractional part. Let's break it down:

1. Extract Degrees: The whole number part of the decimal degree is your degrees.
2. Calculate Minutes: Take the fractional part of the decimal degree, multiply it by 60. The whole number part of this result is your minutes.
3. Calculate Seconds: Take the fractional part of the minutes calculation, multiply it by 60. This result is your seconds. You can keep decimal precision for seconds.
4. Determine Direction: For latitude, if the original decimal degree was negative, it's South. If positive, it's North. For longitude, if negative, it's West. If positive, it's East. The absolute value of the decimal degree is used for the numerical conversion.

def dd_to_dms(dd_value):
    # Determine the sign (North/South, East/West)
    if dd_value < 0:
        sign = '-' # Or 'S'/'W' for display
        abs_dd = abs(dd_value)
    else:
        sign = '+' # Or 'N'/'E' for display
        abs_dd = dd_value

    # Calculate degrees
    degrees = int(abs_dd)

    # Calculate minutes
    remainder_degrees = abs_dd - degrees
    minutes_float = remainder_degrees * 60
    minutes = int(minutes_float)

    # Calculate seconds
    remainder_minutes = minutes_float - minutes
    seconds = remainder_minutes * 60

    return degrees, minutes, seconds, sign

# Example Usage:
latitude_dd = 40.7128 # New York City latitude
longitude_dd = -74.0060 # New York City longitude

lat_d, lat_m, lat_s, lat_sign = dd_to_dms(latitude_dd)
lon_d, lon_m, lon_s, lon_sign = dd_to_dms(longitude_dd)

print(f"Latitude: {lat_d}° {lat_m}' {lat_s:.2f}"" { 'N' if lat_sign == '+' else 'S'}")
print(f"Longitude: {lon_d}° {lon_m}' {lon_s:.2f}"" { 'E' if lon_sign == '+' else 'W'}")

# Output:
# Latitude: 40° 42' 46.08" N
# Longitude: 74° 0' 21.60" W

Python function to convert decimal degrees to DMS format.

Practical Considerations and Precision

While the conversion itself is straightforward, a few practical points are worth noting:

• Precision: The number of decimal places you retain for seconds determines the precision of your DMS coordinate. For most applications, two decimal places for seconds (e.g., 21.60") is sufficient.
• Rounding: Be mindful of rounding. Standard rounding rules apply when truncating decimal seconds.
• Directional Indicators: Always include the N/S/E/W indicators. Without them, a coordinate like 40° 42' 46.08" is ambiguous; it could be North or South latitude, or East or West longitude.

JavaScript

function ddToDMS(ddValue) { const sign = ddValue < 0 ? '-' : '+'; const absDd = Math.abs(ddValue);

const degrees = Math.floor(absDd);
const remainderDegrees = absDd - degrees;

const minutesFloat = remainderDegrees * 60;
const minutes = Math.floor(minutesFloat);

const remainderMinutes = minutesFloat - minutes;
const seconds = remainderMinutes * 60;

return { degrees, minutes, seconds, sign };

}

const latitudeDd = 40.7128; // New York City latitude const longitudeDd = -74.0060; // New York City longitude

const latDMS = ddToDMS(latitudeDd); const lonDMS = ddToDMS(longitudeDd);

console.log(Latitude: ${latDMS.degrees}° ${latDMS.minutes}' ${latDMS.seconds.toFixed(2)}" ${latDMS.sign === '+' ? 'N' : 'S'}); console.log(Longitude: ${lonDMS.degrees}° ${lonDMS.minutes}' ${lonDMS.seconds.toFixed(2)}" ${lonDMS.sign === '+' ? 'E' : 'W'});

// Output: // Latitude: 40° 42' 46.08" N // Longitude: 74° 0' 21.60" W

Java

public class CoordinateConverter {

public static class DMS {
    public int degrees;
    public int minutes;
    public double seconds;
    public char direction;

    public DMS(int d, int m, double s, char dir) {
        this.degrees = d;
        this.minutes = m;
        this.seconds = s;
        this.direction = dir;
    }
}

public static DMS ddToDMS(double ddValue, boolean isLatitude) {
    char direction;
    if (isLatitude) {
        direction = ddValue < 0 ? 'S' : 'N';
    } else {
        direction = ddValue < 0 ? 'W' : 'E';
    }

    double absDd = Math.abs(ddValue);

    int degrees = (int) absDd;
    double remainderDegrees = absDd - degrees;

    double minutesFloat = remainderDegrees * 60;
    int minutes = (int) minutesFloat;

    double remainderMinutes = minutesFloat - minutes;
    double seconds = remainderMinutes * 60;

    return new DMS(degrees, minutes, seconds, direction);
}

public static void main(String[] args) {
    double latitudeDd = 40.7128; // New York City latitude
    double longitudeDd = -74.0060; // New York City longitude

    DMS latDMS = ddToDMS(latitudeDd, true);
    DMS lonDMS = ddToDMS(longitudeDd, false);

    System.out.printf("Latitude: %d° %d' %.2f\" %c%n", latDMS.degrees, latDMS.minutes, latDMS.seconds, latDMS.direction);
    System.out.printf("Longitude: %d° %d' %.2f\" %c%n", lonDMS.degrees, lonDMS.minutes, lonDMS.seconds, lonDMS.direction);

    // Output:
    // Latitude: 40° 42' 46.08" N
    // Longitude: 74° 0' 21.60" W
}

}