Module:Coordinates: Difference between revisions

Jump to navigation Jump to search
imported>MSGJ
(change requested by User:Hike395 to fix default hemisphere)
imported>Mr. Stradivarius
(add Wikidata tracking categories per protected edit request by User:Multichill at Template talk:Coord#Wikidata tracking; also convert whitespace to tabs)
Line 20: Line 20:
coordinates = {};
coordinates = {};


page_name = mw.uri.encode( mw.title.getCurrentTitle().prefixedText, 'WIKI' );
current_page = mw.title.getCurrentTitle()
page_name = mw.uri.encode( current_page.prefixedText, 'WIKI' );
coord_link = '//tools.wmflabs.org/geohack/geohack.php?pagename=' .. page_name .. '&params='
coord_link = '//tools.wmflabs.org/geohack/geohack.php?pagename=' .. page_name .. '&params='


--[[ Helper function, replacement for {{coord/display/title}} ]]
--[[ Helper function, replacement for {{coord/display/title}} ]]
function displaytitle (s, notes)
function displaytitle (s, notes)
    local l = "[[Geographic coordinate system|Coordinates]]: " .. s
local l = "[[Geographic coordinate system|Coordinates]]: " .. s
    local co = '<span id="coordinates">' .. l .. notes .. '</span>';
local co = '<span id="coordinates">' .. l .. notes .. '</span>';
    return '<span style="font-size: small;">' .. co .. '</span>';
return '<span style="font-size: small;">' .. co .. '</span>';
end
end


--[[ Helper function, Replacement for {{coord/display/inline}} ]]
--[[ Helper function, Replacement for {{coord/display/inline}} ]]
function displayinline (s, notes)
function displayinline (s, notes)
    return s .. notes  
return s .. notes
end
end


--[[ Helper function, used in detecting DMS formatting ]]
--[[ Helper function, used in detecting DMS formatting ]]
local dmsTest = function(first, second)
local dmsTest = function(first, second)
    local concatenated = first:upper() .. second:upper();
local concatenated = first:upper() .. second:upper();
   
    if concatenated == "NE" or concatenated == "NW" or concatenated == "SE" or concatenated == "SW" or
if concatenated == "NE" or concatenated == "NW" or concatenated == "SE" or concatenated == "SW" or
        concatenated == "EN" or concatenated == "WN" or concatenated == "ES" or concatenated == "WS" then
concatenated == "EN" or concatenated == "WN" or concatenated == "ES" or concatenated == "WS" then
        return true;
return true;
    end
end
    return false;
return false;
end
end


Line 53: Line 54:
]]
]]
function parseDec( lat, long, format )
function parseDec( lat, long, format )
    local coordinateSpec = {}
local coordinateSpec = {}
    local errors = {}
local errors = {}
   
    if long == "" or long == nil then
if long == "" or long == nil then
        return nil, {{"parseDec", "Missing longitude"}}
return nil, {{"parseDec", "Missing longitude"}}
    end
end
   
    errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );  
errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );
    coordinateSpec["dec-lat"]  = lat;
coordinateSpec["dec-lat"]  = lat;
    coordinateSpec["dec-long"] = long;
coordinateSpec["dec-long"] = long;


    local mode = coordinates.determineMode( lat, long );
local mode = coordinates.determineMode( lat, long );
    coordinateSpec["dms-lat"]  = convert_dec2dms( lat, "N", "S", mode)  -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
coordinateSpec["dms-lat"]  = convert_dec2dms( lat, "N", "S", mode)  -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
    coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode)  -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}  
coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode)  -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
   
    if format ~= "" then
if format ~= "" then
        coordinateSpec.default = format
coordinateSpec.default = format
    else
else
        coordinateSpec.default = "dec"
coordinateSpec.default = "dec"
    end
end


    return coordinateSpec, errors
return coordinateSpec, errors
end
end


--[[ Helper function, handle optional args. ]]
--[[ Helper function, handle optional args. ]]
function optionalArg(arg, suplement)
function optionalArg(arg, suplement)
    if arg ~= nil and arg ~= "" then
if arg ~= nil and arg ~= "" then
        return arg .. suplement
return arg .. suplement
    end
end
    return ""
return ""
end
end


Line 92: Line 93:
]]
]]
function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
    local coordinateSpec = {}
local coordinateSpec = {}
    local errors = {}
local errors = {}
   
    lat_f = lat_f:upper();
lat_f = lat_f:upper();
    long_f = long_f:upper();
long_f = long_f:upper();
   
    -- Check if specified backward
-- Check if specified backward
    if lat_f == 'E' or lat_f == 'W' then
if lat_f == 'E' or lat_f == 'W' then
        local t_d, t_m, t_s, t_f;
local t_d, t_m, t_s, t_f;
        t_d = lat_d;
t_d = lat_d;
        t_m = lat_m;
t_m = lat_m;
        t_s = lat_s;
t_s = lat_s;
        t_f = lat_f;
t_f = lat_f;
        lat_d = long_d;
lat_d = long_d;
        lat_m = long_m;
lat_m = long_m;
        lat_s = long_s;
lat_s = long_s;
        lat_f = long_f;
lat_f = long_f;
        long_d = t_d;
long_d = t_d;
        long_m = t_m;
long_m = t_m;
        long_s = t_s;
long_s = t_s;
        long_f = t_f;
long_f = t_f;
    end  
end
   
    errors = validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, 'parseDMS', true );
errors = validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, 'parseDMS', true );
    if long_d == nil or long_d == "" then
if long_d == nil or long_d == "" then
        table.insert(errors, {"parseDMS", "Missing longitude" })
table.insert(errors, {"parseDMS", "Missing longitude" })
    end
end
   
    if lat_m == nil and lat_s == nil and long_m == nil and long_s == nil and #errors == 0 then  
if lat_m == nil and lat_s == nil and long_m == nil and long_s == nil and #errors == 0 then  
        if math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
if math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
            if lat_f:upper() == 'S' then  
if lat_f:upper() == 'S' then  
                lat_d = '-' .. lat_d;
lat_d = '-' .. lat_d;
            end
end
            if long_f:upper() == 'W' then  
if long_f:upper() == 'W' then  
                long_d = '-' .. long_d;
long_d = '-' .. long_d;
            end    
end
           
            return parseDec( lat_d, long_d, format );
return parseDec( lat_d, long_d, format );
        end      
end
    end   
end   
   
    coordinateSpec["dms-lat"]  = lat_d.."°"..optionalArg(lat_m,"′") .. optionalArg(lat_s,"″") .. lat_f
coordinateSpec["dms-lat"]  = lat_d.."°"..optionalArg(lat_m,"′") .. optionalArg(lat_s,"″") .. lat_f
    coordinateSpec["dms-long"] = long_d.."°"..optionalArg(long_m,"′") .. optionalArg(long_s,"″") .. long_f
coordinateSpec["dms-long"] = long_d.."°"..optionalArg(long_m,"′") .. optionalArg(long_s,"″") .. long_f
    coordinateSpec["dec-lat"]  = convert_dms2dec(lat_f, lat_d, lat_m, lat_s) -- {{coord/dms2dec|{{{4}}}|{{{1}}}|0{{{2}}}|0{{{3}}}}}
coordinateSpec["dec-lat"]  = convert_dms2dec(lat_f, lat_d, lat_m, lat_s) -- {{coord/dms2dec|{{{4}}}|{{{1}}}|0{{{2}}}|0{{{3}}}}}
    coordinateSpec["dec-long"] = convert_dms2dec(long_f, long_d, long_m, long_s) -- {{coord/dms2dec|{{{8}}}|{{{5}}}|0{{{6}}}|0{{{7}}}}}
coordinateSpec["dec-long"] = convert_dms2dec(long_f, long_d, long_m, long_s) -- {{coord/dms2dec|{{{8}}}|{{{5}}}|0{{{6}}}|0{{{7}}}}}


    if format ~= "" then
if format ~= "" then
        coordinateSpec.default = format
coordinateSpec.default = format
    else
else
        coordinateSpec.default = "dms"
coordinateSpec.default = "dms"
    end   
end   


    return coordinateSpec, errors
return coordinateSpec, errors
end
end


Line 154: Line 155:
]]
]]
function specPrinter(args, coordinateSpec)
function specPrinter(args, coordinateSpec)
    local uriComponents = coordinateSpec["param"]
local uriComponents = coordinateSpec["param"]
    if uriComponents == "" then
if uriComponents == "" then
        -- RETURN error, should never be empty or nil
-- RETURN error, should never be empty or nil
        return "ERROR param was empty"
return "ERROR param was empty"
    end
end
    if args["name"] ~= "" and args["name"] ~= nil then
if args["name"] ~= "" and args["name"] ~= nil then
        uriComponents = uriComponents .. "&title=" .. mw.uri.encode(coordinateSpec["name"])
uriComponents = uriComponents .. "&title=" .. mw.uri.encode(coordinateSpec["name"])
    end
end
   
    local geodmshtml = '<span class="geo-dms" title="Maps, aerial photos, and other data for this location">'
local geodmshtml = '<span class="geo-dms" title="Maps, aerial photos, and other data for this location">'
            .. '<span class="latitude">' .. coordinateSpec["dms-lat"] .. '</span> '
.. '<span class="latitude">' .. coordinateSpec["dms-lat"] .. '</span> '
            .. '<span class="longitude">' ..coordinateSpec["dms-long"] .. '</span>'
.. '<span class="longitude">' ..coordinateSpec["dms-long"] .. '</span>'
            .. '</span>'
.. '</span>'


    local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
    if lat < 0 then
if lat < 0 then
        -- FIXME this breaks the pre-existing precision
-- FIXME this breaks the pre-existing precision
        geodeclat = coordinateSpec["dec-lat"]:sub(2) .. "°S"
geodeclat = coordinateSpec["dec-lat"]:sub(2) .. "°S"
    else
else
        geodeclat = (coordinateSpec["dec-lat"] or 0) .. "°N"
geodeclat = (coordinateSpec["dec-lat"] or 0) .. "°N"
    end
end


    local long = tonumber( coordinateSpec["dec-long"] ) or 0
local long = tonumber( coordinateSpec["dec-long"] ) or 0
    if long < 0 then
if long < 0 then
        -- FIXME does not handle unicode minus
-- FIXME does not handle unicode minus
        geodeclong = coordinateSpec["dec-long"]:sub(2) .. "°W"
geodeclong = coordinateSpec["dec-long"]:sub(2) .. "°W"
    else
else
        geodeclong = (coordinateSpec["dec-long"] or 0) .. "°E"
geodeclong = (coordinateSpec["dec-long"] or 0) .. "°E"
    end
end
   
    local geodechtml = '<span class="geo-dec" title="Maps, aerial photos, and other data for this location">'
local geodechtml = '<span class="geo-dec" title="Maps, aerial photos, and other data for this location">'
            .. geodeclat .. ' '
.. geodeclat .. ' '
            .. geodeclong
.. geodeclong
            .. '</span>'
.. '</span>'


    local geonumhtml = '<span class="geo">'
local geonumhtml = '<span class="geo">'
            .. coordinateSpec["dec-lat"] .. '; '
.. coordinateSpec["dec-lat"] .. '; '
            .. coordinateSpec["dec-long"]
.. coordinateSpec["dec-long"]
            .. '</span>'
.. '</span>'


    local inner;
local inner;
    inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
                .. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
.. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
                .. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';
.. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';


    if args["name"] == "" or args["name"] == nil then
if args["name"] == "" or args["name"] == nil then
        inner = inner .. geodechtml  
inner = inner .. geodechtml  
                .. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></span>'
.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></span>'
    else
else
        inner = inner .. '<span class="vcard">' .. geodechtml  
inner = inner .. '<span class="vcard">' .. geodechtml  
                .. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span>'
.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span>'
                .. '<span style="display:none">&#xfeff; (<span class="fn org">'
.. '<span style="display:none">&#xfeff; (<span class="fn org">'
                .. args["name"] .. '</span>)</span></span></span>'
.. args["name"] .. '</span>)</span></span></span>'
    end
end


    return '<span class="plainlinks nourlexpansion">' ..  
return '<span class="plainlinks nourlexpansion">' ..  
        '[' .. coord_link .. uriComponents .. ' ' .. inner .. ']' .. '</span>'
'[' .. coord_link .. uriComponents .. ' ' .. inner .. ']' .. '</span>'
end
end


Line 217: Line 218:
]]
]]
function errorPrinter(errors)
function errorPrinter(errors)
    local result = ""
local result = ""
    for i,v in ipairs(errors) do
for i,v in ipairs(errors) do
        local errorHTML = '<strong class="error">Coordinates: ' .. v[2] .. '</strong>'
local errorHTML = '<strong class="error">Coordinates: ' .. v[2] .. '</strong>'
        result = result .. errorHTML .. "<br />"
result = result .. errorHTML .. "<br />"
    end
end
    return result
return result
end
end


Line 233: Line 234:
]]
]]
function displayDefault(default, mode)
function displayDefault(default, mode)
    if default == "" then
if default == "" then
        default = "dec"
default = "dec"
    end
end
   
    if default == mode then
if default == mode then
        return "geo-default"
return "geo-default"
    else
else
        return "geo-nondefault"
return "geo-nondefault"
    end
end
end
end


Line 249: Line 250:
]]
]]
function formatTest(args)
function formatTest(args)
    local result, errors;
local result, errors;
    local primary = false;
local primary = false;
   
    if args[1] == "" then
if args[1] == "" then
        -- no lat logic
-- no lat logic
        return errorPrinter( {{"formatTest", "Missing latitude"}} )
return errorPrinter( {{"formatTest", "Missing latitude"}} )
    elseif args[4] == "" and args[5] == "" and args[6] == "" then
elseif args[4] == "" and args[5] == "" and args[6] == "" then
        -- dec logic
-- dec logic
        result, errors = parseDec( args[1], args[2], args['format'] )
result, errors = parseDec( args[1], args[2], args['format'] )
        if result == nil then
if result == nil then
            return errorPrinter( errors );
return errorPrinter( errors );
        end            
end  
        result.param   = table.concat( {args[1], "_N_", args[2], "_E_", args[3] } );
result.param = table.concat( {args[1], "_N_", args[2], "_E_", args[3] } );
    elseif dmsTest(args[4], args[8]) then
elseif dmsTest(args[4], args[8]) then
        -- dms logic
-- dms logic
        result, errors = parseDMS( args[1], args[2], args[3], args[4],  
result, errors = parseDMS( args[1], args[2], args[3], args[4],  
            args[5], args[6], args[7], args[8], args['format'] )
args[5], args[6], args[7], args[8], args['format'] )
        result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
            args[6], args[7], args[8], args[9] } , '_' );
args[6], args[7], args[8], args[9] } , '_' );
        if args[10] ~= '' then
if args[10] ~= '' then
            table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
        end      
end
    elseif dmsTest(args[3], args[6]) then
elseif dmsTest(args[3], args[6]) then
        -- dm logic
-- dm logic
        result, errors = parseDMS( args[1], args[2], nil, args[3],  
result, errors = parseDMS( args[1], args[2], nil, args[3],  
            args[4], args[5], nil, args[6], args['format'] )
args[4], args[5], nil, args[6], args['format'] )
        result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
            args[6], args[7] } , '_' );
args[6], args[7] } , '_' );
        if args[8] ~= '' then
if args[8] ~= '' then
            table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
        end      
end
    elseif dmsTest(args[2], args[4]) then
elseif dmsTest(args[2], args[4]) then
        -- d logic
-- d logic
        result, errors = parseDMS( args[1], nil, nil, args[2],  
result, errors = parseDMS( args[1], nil, nil, args[2],  
            args[3], nil, nil, args[4], args['format'] )
args[3], nil, nil, args[4], args['format'] )
        result.param = table.concat( { args[1], args[2], args[3], args[4], args[5] } , '_' );
result.param = table.concat( { args[1], args[2], args[3], args[4], args[5] } , '_' );
        if args[6] ~= '' then
if args[6] ~= '' then
            table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
        end      
end
    else
else
        -- Error
-- Error
        return errorPrinter( {{"formatTest", "Unknown argument format"}} )
return errorPrinter( {{"formatTest", "Unknown argument format"}} )
    end
end
    result.name     = args["name"]
result.name = args["name"]
   
    local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
    for _, v in ipairs( extra_param ) do
for _, v in ipairs( extra_param ) do
        if (args[v] or '') ~= '' then  
if (args[v] or '') ~= '' then  
            table.insert( errors, {'formatTest', 'Parameter: "' .. v .. '=" should be "' .. v .. ':"' } );
table.insert( errors, {'formatTest', 'Parameter: "' .. v .. '=" should be "' .. v .. ':"' } );
        end
end
    end
end
   
    if #errors == 0 then
if #errors == 0 then
        return specPrinter( args, result )  
return specPrinter( args, result )
    else
else
        return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '[[Category:Pages with malformed coordinate tags]]';  
return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '[[Category:Pages with malformed coordinate tags]]';  
    end  
end
end
end


Line 313: Line 314:
]]
]]
function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
    local coord = tonumber(coordinate) or 0
local coord = tonumber(coordinate) or 0
    local postfix
local postfix
    if coord >= 0 then
if coord >= 0 then
        postfix = firstPostfix
postfix = firstPostfix
    else
else
        postfix = secondPostfix
postfix = secondPostfix
    end
end


    precision = precision:lower();
precision = precision:lower();
    if precision == "dms" then
if precision == "dms" then
        return convert_dec2dms_dms( math.abs( coord ) ) .. postfix;
return convert_dec2dms_dms( math.abs( coord ) ) .. postfix;
    elseif precision == "dm" then
elseif precision == "dm" then
        return convert_dec2dms_dm( math.abs( coord ) ) .. postfix;
return convert_dec2dms_dm( math.abs( coord ) ) .. postfix;
    elseif precision == "d" then
elseif precision == "d" then
        return convert_dec2dms_d( math.abs( coord ) ) .. postfix;
return convert_dec2dms_d( math.abs( coord ) ) .. postfix;
    end
end
end
end


--[[ Helper function, convert decimal to degrees ]]
--[[ Helper function, convert decimal to degrees ]]
function convert_dec2dms_d(coordinate)
function convert_dec2dms_d(coordinate)
    local d = math_mod._round( coordinate, 0 ) .. "°"
local d = math_mod._round( coordinate, 0 ) .. "°"
    return d .. ""
return d .. ""
end
end


--[[ Helper function, convert decimal to degrees and minutes ]]
--[[ Helper function, convert decimal to degrees and minutes ]]
function convert_dec2dms_dm(coordinate)  
function convert_dec2dms_dm(coordinate)
    coordinate = math_mod._round( coordinate * 60, 0 );
coordinate = math_mod._round( coordinate * 60, 0 );
    local m = coordinate % 60;
local m = coordinate % 60;
    coordinate = math.floor( (coordinate - m) / 60 );
coordinate = math.floor( (coordinate - m) / 60 );
    local d = coordinate % 360 .."°"
local d = coordinate % 360 .."°"
   
    return d .. string.format( "%02d′", m )
return d .. string.format( "%02d′", m )
end
end


--[[ Helper function, convert decimal to degrees, minutes, and seconds ]]
--[[ Helper function, convert decimal to degrees, minutes, and seconds ]]
function convert_dec2dms_dms(coordinate)
function convert_dec2dms_dms(coordinate)
    coordinate = math_mod._round( coordinate * 60 * 60, 0 );
coordinate = math_mod._round( coordinate * 60 * 60, 0 );
    local s = coordinate % 60
local s = coordinate % 60
    coordinate = math.floor( (coordinate - s) / 60 );
coordinate = math.floor( (coordinate - s) / 60 );
    local m = coordinate % 60
local m = coordinate % 60
    coordinate = math.floor( (coordinate - m) / 60 );
coordinate = math.floor( (coordinate - m) / 60 );
    local d = coordinate % 360 .."°"
local d = coordinate % 360 .."°"


    return d .. string.format( "%02d′", m ) .. string.format( "%02d″", s )
return d .. string.format( "%02d′", m ) .. string.format( "%02d″", s )
end
end


Line 363: Line 364:
]]
]]
function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
    local degrees = tonumber(degrees_str) or 0
local degrees = tonumber(degrees_str) or 0
    local minutes = tonumber(minutes_str) or 0
local minutes = tonumber(minutes_str) or 0
    local seconds = tonumber(seconds_str) or 0
local seconds = tonumber(seconds_str) or 0
   
    local factor = 1
local factor = 1
    direction = mw.ustring.gsub(direction, '^[ ]*(.-)[ ]*$', '%1');
direction = mw.ustring.gsub(direction, '^[ ]*(.-)[ ]*$', '%1');
    if direction == "S" or direction == "W" then
if direction == "S" or direction == "W" then
        factor = -1
factor = -1
    end
end
   
    local precision = 0
local precision = 0
    if seconds_str ~= nil and seconds_str ~= '' then
if seconds_str ~= nil and seconds_str ~= '' then
        precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
    elseif minutes_str ~= nil and minutes_str ~= '' then
elseif minutes_str ~= nil and minutes_str ~= '' then
        precision = 3 + math.max( math_mod._precision(minutes_str), 0 );
precision = 3 + math.max( math_mod._precision(minutes_str), 0 );
    else
else
        precision = math.max( math_mod._precision(degrees_str), 0 );
precision = math.max( math_mod._precision(degrees_str), 0 );
    end
end
   
    local decimal = factor * (degrees+(minutes+seconds/60)/60)  
local decimal = factor * (degrees+(minutes+seconds/60)/60)  
    return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
end
end


Line 390: Line 391:
]]
]]
function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
    local errors = {};
local errors = {};
    lat_d = tonumber( lat_d ) or 0;
lat_d = tonumber( lat_d ) or 0;
    lat_m = tonumber( lat_m ) or 0;
lat_m = tonumber( lat_m ) or 0;
    lat_s = tonumber( lat_s ) or 0;
lat_s = tonumber( lat_s ) or 0;
    long_d = tonumber( long_d ) or 0;
long_d = tonumber( long_d ) or 0;
    long_m = tonumber( long_m ) or 0;
long_m = tonumber( long_m ) or 0;
    long_s = tonumber( long_s ) or 0;
long_s = tonumber( long_s ) or 0;


    if strong then
if strong then
        if lat_d < 0 then
if lat_d < 0 then
            table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
        end
end
        if long_d < 0 then
if long_d < 0 then
            table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
        end
end
        --[[  
--[[  
        #coordinates is inconsistent about whether this is an error.  If globe: is
#coordinates is inconsistent about whether this is an error.  If globe: is
        specified, it won't error on this condition, but otherwise it will.
specified, it won't error on this condition, but otherwise it will.
       
        For not simply disable this check.
For not simply disable this check.
       
        if long_d > 180 then
if long_d > 180 then
            table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
        end
end
        ]]
]]
    end  
end
       
    if lat_d > 90 then
if lat_d > 90 then
        table.insert(errors, {source, "latitude degrees > 90"})
table.insert(errors, {source, "latitude degrees > 90"})
    end
end
    if lat_d < -90 then
if lat_d < -90 then
        table.insert(errors, {source, "latitude degrees < -90"})
table.insert(errors, {source, "latitude degrees < -90"})
    end
end
    if lat_m >= 60 then
if lat_m >= 60 then
        table.insert(errors, {source, "latitude minutes >= 60"})
table.insert(errors, {source, "latitude minutes >= 60"})
    end
end
    if lat_m < 0 then
if lat_m < 0 then
        table.insert(errors, {source, "latitude minutes < 0"})
table.insert(errors, {source, "latitude minutes < 0"})
    end
end
    if lat_s >= 60 then
if lat_s >= 60 then
        table.insert(errors, {source, "latitude seconds >= 60"})
table.insert(errors, {source, "latitude seconds >= 60"})
    end
end
    if lat_s < 0 then
if lat_s < 0 then
        table.insert(errors, {source, "latitude seconds < 0"})
table.insert(errors, {source, "latitude seconds < 0"})
    end
end
    if long_d >= 360 then
if long_d >= 360 then
        table.insert(errors, {source, "longitude degrees >= 360"})
table.insert(errors, {source, "longitude degrees >= 360"})
    end
end
    if long_d <= -360 then
if long_d <= -360 then
        table.insert(errors, {source, "longitude degrees <= -360"})
table.insert(errors, {source, "longitude degrees <= -360"})
    end
end
    if long_m >= 60 then
if long_m >= 60 then
        table.insert(errors, {source, "longitude minutes >= 60"})
table.insert(errors, {source, "longitude minutes >= 60"})
    end
end
    if long_m < 0 then
if long_m < 0 then
        table.insert(errors, {source, "longitude minutes < 0"})
table.insert(errors, {source, "longitude minutes < 0"})
    end
end
    if long_s >= 60 then
if long_s >= 60 then
        table.insert(errors, {source, "longitude seconds >= 60"})
table.insert(errors, {source, "longitude seconds >= 60"})
    end
end
    if long_s < 0 then
if long_s < 0 then
        table.insert(errors, {source, "longitude seconds < 0"})
table.insert(errors, {source, "longitude seconds < 0"})
    end
end
   
    return errors;
return errors;
end
end


Line 463: Line 464:


Usage:
Usage:
    {{ Invoke:Coordinates | link }}
{{ Invoke:Coordinates | link }}
   
]]
]]
function coordinates.link(frame)
function coordinates.link(frame)
    return coord_link;
return coord_link;
end
end


Line 476: Line 477:


Usage:
Usage:
    {{ Invoke:Coordinates | dec2dms | decimal_coordinate | positive_suffix |  
{{ Invoke:Coordinates | dec2dms | decimal_coordinate | positive_suffix |  
        negative_suffix | precision }}
negative_suffix | precision }}
   
decimal_coordinate is converted to DMS format.  If positive, the positive_suffix
decimal_coordinate is converted to DMS format.  If positive, the positive_suffix
is appended (typical N or E), if negative, the negative suffix is appended.  The
is appended (typical N or E), if negative, the negative suffix is appended.  The
Line 485: Line 486:
]]
]]
function coordinates.dec2dms(frame)
function coordinates.dec2dms(frame)
    globalFrame = frame
globalFrame = frame
    local coordinate = frame.args[1]
local coordinate = frame.args[1]
    local firstPostfix = frame.args[2]
local firstPostfix = frame.args[2]
    local secondPostfix = frame.args[3]
local secondPostfix = frame.args[3]
    local precision = frame.args[4]
local precision = frame.args[4]


    return convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
return convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
end
end


Line 499: Line 500:
]]
]]
function coordinates.determineMode( value1, value2 )
function coordinates.determineMode( value1, value2 )
    local precision = math.max( math_mod._precision( value1 ), math_mod._precision( value2 ) );
local precision = math.max( math_mod._precision( value1 ), math_mod._precision( value2 ) );
    if precision <= 0 then
if precision <= 0 then
        return 'd'
return 'd'
    elseif precision <= 2 then
elseif precision <= 2 then
        return 'dm';
return 'dm';
    else
else
        return 'dms';
return 'dms';
    end
end
end      
end


--[[
--[[
Line 515: Line 516:


Usage:
Usage:
    {{ Invoke:Coordinates | dms2dec | direction_flag | degrees |  
{{ Invoke:Coordinates | dms2dec | direction_flag | degrees |  
        minutes | seconds }}
minutes | seconds }}
   
Converts DMS values specified as degrees, minutes, seconds too decimal format.
Converts DMS values specified as degrees, minutes, seconds too decimal format.
direction_flag is one of N, S, E, W, and determines whether the output is  
direction_flag is one of N, S, E, W, and determines whether the output is  
Line 523: Line 524:
]]
]]
function coordinates.dms2dec(frame)
function coordinates.dms2dec(frame)
    globalFrame = frame
globalFrame = frame
    local direction = frame.args[1]
local direction = frame.args[1]
    local degrees = frame.args[2]
local degrees = frame.args[2]
    local minutes = frame.args[3]
local minutes = frame.args[3]
    local seconds = frame.args[4]
local seconds = frame.args[4]


    return convert_dms2dec(direction, degrees, minutes, seconds)
return convert_dms2dec(direction, degrees, minutes, seconds)
end
end


Line 538: Line 539:


Usage:
Usage:
    {{ Invoke:Coordinates | coord }}
{{ Invoke:Coordinates | coord }}
    {{ Invoke:Coordinates | coord | lat | long }}
{{ Invoke:Coordinates | coord | lat | long }}
    {{ Invoke:Coordinates | coord | lat | lat_flag | long | long_flag }}
{{ Invoke:Coordinates | coord | lat | lat_flag | long | long_flag }}
    ...
...
   
    Refer to {{coord}} documentation page for many additional parameters and  
Refer to {{coord}} documentation page for many additional parameters and  
    configuration options.
configuration options.
   
Note: This function provides the visual display elements of {{coord}}.  In
Note: This function provides the visual display elements of {{coord}}.  In
order to load coordinates into the database, the {{#coordinates:}} parser  
order to load coordinates into the database, the {{#coordinates:}} parser  
Line 552: Line 553:
]]
]]
function coordinates.coord(frame)
function coordinates.coord(frame)
    globalFrame = frame
globalFrame = frame
    local args = frame.args
local args = frame.args
    if args[1] == nil then
if args[1] == nil then
        local pFrame = frame:getParent();
local pFrame = frame:getParent();
        args = pFrame.args;
args = pFrame.args;
        for k,v in pairs( frame.args ) do
for k,v in pairs( frame.args ) do
            args[k] = v;
args[k] = v;
        end
end
    end
end
   
    for i=1,10 do  
for i=1,10 do  
        if args[i] == nil then  
if args[i] == nil then  
            args[i] = ""
args[i] = ""
        else
else
            args[i] = args[i]:match( '^%s*(.-)%s*$' );  --remove whitespace
args[i] = args[i]:match( '^%s*(.-)%s*$' );  --remove whitespace
        end      
end
    end
end
    args['format'] = args['format'] or '';
args['format'] = args['format'] or '';
   
    local contents = formatTest(args)
local contents = formatTest(args)
    local Notes = args.notes or ""
local Notes = args.notes or ""
    local Display = string.lower(args.display or "inline")
local Display = string.lower(args.display or "inline")
    if Display == '' then
if Display == '' then
        Display = 'inline';
Display = 'inline';
    end
end
   
    local text = ''
local text = ''
    if string.find( Display, 'inline' ) ~= nil or Display == 'i' or  
local valid_Display = false
            Display == 'it' or Display == 'ti' then
if string.find( Display, 'inline' ) ~= nil or Display == 'i' or  
        text = displayinline(contents, Notes)
Display == 'it' or Display == 'ti' then
    end
text = displayinline(contents, Notes)
    if string.find( Display, 'title' ) ~= nil or Display == 't' or  
valid_Display = true
            Display == 'it' or Display == 'ti' then
end
        text = text .. displaytitle(contents, Notes)
if string.find( Display, 'title' ) ~= nil or Display == 't' or  
    end
Display == 'it' or Display == 'ti' then
    return text
text = text .. displaytitle(contents, Notes)
valid_Display = true
end
local wikidata_cat
if valid_Display and mw.wikibase and current_page.namespace == 0 then -- add the appropriate Wikidata category for main namespace pages
local entity = mw.wikibase.getEntity()
if entity and entity.claims.p625 then
local snaktype = entity.claims.p625[0].mainsnak.snaktype
if snaktype == 'value' then
wikidata_cat = '[[Category:Coordinates on Wikidata]]' -- coordinates exist both here and on Wikidata, and can be compared
elseif snaktype == 'somevalue' then
wikidata_cat = '[[Category:Coordinates on Wikidata set to unknown value]]'
elseif snaktype == 'novalue' then
wikidata_cat = '[[Category:Coordinates on Wikidata set to no value]]'
end
else
wikidata_cat = '[[Category:Coordinates not on Wikidata]]' -- we have to either import the coordinates to Wikidata or remove them here
end
end
wikidata_cat = wikidata_cat or ''
text = text .. wikidata_cat
return text
end
end


return coordinates
return coordinates

Revision as of 03:35, 22 November 2013

Documentation for this module may be created at Module:Coordinates/doc

--[[
This module is intended to replace the functionality of {{Coord}} and related
templates.  It provides several methods, including

{{#Invoke:Coordinates | coord }} : General function formatting and displaying
coordinate values.

{{#Invoke:Coordinates | dec2dms }} : Simple function for converting decimal
degree values to DMS format.

{{#Invoke:Coordinates | dms2dec }} : Simple function for converting DMS format
to decimal degree format.

{{#Invoke:Coordinates | link }} : Export the link used to reach the tools

]]

math_mod = require( "Module:Math" );
globalFrame = nil
coordinates = {};

current_page = mw.title.getCurrentTitle()
page_name = mw.uri.encode( current_page.prefixedText, 'WIKI' );
coord_link = '//tools.wmflabs.org/geohack/geohack.php?pagename=' .. page_name .. '&params='

--[[ Helper function, replacement for {{coord/display/title}} ]]
function displaytitle (s, notes)
	local l = "[[Geographic coordinate system|Coordinates]]: " .. s
	local co = '<span id="coordinates">' .. l .. notes .. '</span>';
	return '<span style="font-size: small;">' .. co .. '</span>';
end

--[[ Helper function, Replacement for {{coord/display/inline}} ]]
function displayinline (s, notes)
	return s .. notes	
end

--[[ Helper function, used in detecting DMS formatting ]]
local dmsTest = function(first, second)
	local concatenated = first:upper() .. second:upper();
	
	if concatenated == "NE" or concatenated == "NW" or concatenated == "SE" or concatenated == "SW" or
		concatenated == "EN" or concatenated == "WN" or concatenated == "ES" or concatenated == "WS" then
		return true;
	end
	return false;
end

--[[
parseDec

Transforms decimal format latitude and longitude into the a
structure to be used in displaying coordinates
]]
function parseDec( lat, long, format )
	local coordinateSpec = {}
	local errors = {}
	
	if long == "" or long == nil then
		return nil, {{"parseDec", "Missing longitude"}}
	end
	
	errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );	
	coordinateSpec["dec-lat"]  = lat;
	coordinateSpec["dec-long"] = long;

	local mode = coordinates.determineMode( lat, long );
	coordinateSpec["dms-lat"]  = convert_dec2dms( lat, "N", "S", mode)  -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
	coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode)  -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}	
	
	if format ~= "" then
		coordinateSpec.default = format
	else
		coordinateSpec.default = "dec"
	end

	return coordinateSpec, errors
end

--[[ Helper function, handle optional args. ]]
function optionalArg(arg, suplement)
	if arg ~= nil and arg ~= "" then
		return arg .. suplement
	end
	return ""
end

--[[
parseDMS

Transforms degrees, minutes, seconds format latitude and longitude 
into the a structure to be used in displaying coordinates
]]
function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
	local coordinateSpec = {}
	local errors = {}
	
	lat_f = lat_f:upper();
	long_f = long_f:upper();
	
	-- Check if specified backward
	if lat_f == 'E' or lat_f == 'W' then
		local t_d, t_m, t_s, t_f;
		t_d = lat_d;
		t_m = lat_m;
		t_s = lat_s;
		t_f = lat_f;
		lat_d = long_d;
		lat_m = long_m;
		lat_s = long_s;
		lat_f = long_f;
		long_d = t_d;
		long_m = t_m;
		long_s = t_s;
		long_f = t_f;
	end	
	
	errors = validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, 'parseDMS', true );
	if long_d == nil or long_d == "" then
		table.insert(errors, {"parseDMS", "Missing longitude" })
	end
	
	if lat_m == nil and lat_s == nil and long_m == nil and long_s == nil and #errors == 0 then 
		if math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
			if lat_f:upper() == 'S' then 
				lat_d = '-' .. lat_d;
			end
			if long_f:upper() == 'W' then 
				long_d = '-' .. long_d;
			end	 
			
			return parseDec( lat_d, long_d, format );
		end		
	end   
	
	coordinateSpec["dms-lat"]  = lat_d.."°"..optionalArg(lat_m,"′") .. optionalArg(lat_s,"″") .. lat_f
	coordinateSpec["dms-long"] = long_d.."°"..optionalArg(long_m,"′") .. optionalArg(long_s,"″") .. long_f
	coordinateSpec["dec-lat"]  = convert_dms2dec(lat_f, lat_d, lat_m, lat_s) -- {{coord/dms2dec|{{{4}}}|{{{1}}}|0{{{2}}}|0{{{3}}}}}
	coordinateSpec["dec-long"] = convert_dms2dec(long_f, long_d, long_m, long_s) -- {{coord/dms2dec|{{{8}}}|{{{5}}}|0{{{6}}}|0{{{7}}}}}

	if format ~= "" then
		coordinateSpec.default = format
	else
		coordinateSpec.default = "dms"
	end   

	return coordinateSpec, errors
end

--[[
specPrinter

Output formatter.  Takes the structure generated by either parseDec
or parseDMS and formats it for inclusion on Wikipedia.
]]
function specPrinter(args, coordinateSpec)
	local uriComponents = coordinateSpec["param"]
	if uriComponents == "" then
		-- RETURN error, should never be empty or nil
		return "ERROR param was empty"
	end
	if args["name"] ~= "" and args["name"] ~= nil then
		uriComponents = uriComponents .. "&title=" .. mw.uri.encode(coordinateSpec["name"])
	end
	
	local geodmshtml = '<span class="geo-dms" title="Maps, aerial photos, and other data for this location">'
			 .. '<span class="latitude">' .. coordinateSpec["dms-lat"] .. '</span> '
			 .. '<span class="longitude">' ..coordinateSpec["dms-long"] .. '</span>'
			 .. '</span>'

	local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
	if lat < 0 then
		-- FIXME this breaks the pre-existing precision
		geodeclat = coordinateSpec["dec-lat"]:sub(2) .. "°S"
	else
		geodeclat = (coordinateSpec["dec-lat"] or 0) .. "°N"
	end

	local long = tonumber( coordinateSpec["dec-long"] ) or 0
	if long < 0 then
		-- FIXME does not handle unicode minus
		geodeclong = coordinateSpec["dec-long"]:sub(2) .. "°W"
	else
		geodeclong = (coordinateSpec["dec-long"] or 0) .. "°E"
	end
	
	local geodechtml = '<span class="geo-dec" title="Maps, aerial photos, and other data for this location">'
			 .. geodeclat .. ' '
			 .. geodeclong
			 .. '</span>'

	local geonumhtml = '<span class="geo">'
			 .. coordinateSpec["dec-lat"] .. '; '
			 .. coordinateSpec["dec-long"]
			 .. '</span>'

	local inner;
	inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
				.. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
				.. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';

	if args["name"] == "" or args["name"] == nil then
		inner = inner .. geodechtml 
				.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></span>'
	else
		inner = inner .. '<span class="vcard">' .. geodechtml 
				.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span>'
				.. '<span style="display:none">&#xfeff; (<span class="fn org">'
				.. args["name"] .. '</span>)</span></span></span>'
	end

	return '<span class="plainlinks nourlexpansion">' .. 
		'[' .. coord_link .. uriComponents .. ' ' .. inner .. ']' .. '</span>'
end

--[[
Formats any error messages generated for display
]]
function errorPrinter(errors)
	local result = ""
	for i,v in ipairs(errors) do
		local errorHTML = '<strong class="error">Coordinates: ' .. v[2] .. '</strong>'
		result = result .. errorHTML .. "<br />"
	end
	return result
end

--[[
Determine the required CSS class to display coordinates

Usually geo-nondefault is hidden by CSS, unless a user has overridden this for himself
default is the mode as specificied by the user when calling the {{coord}} template
mode is the display mode (dec or dms) that we will need to determine the css class for 
]]
function displayDefault(default, mode)
	if default == "" then
		default = "dec"
	end
	
	if default == mode then
		return "geo-default"
	else
		return "geo-nondefault"
	end
end

--[[ 
Check the input arguments for coord to determine the kind of data being provided
and then make the necessary processing.
]]
function formatTest(args)
	local result, errors;
	local primary = false;
	
	if args[1] == "" then
		-- no lat logic
		return errorPrinter( {{"formatTest", "Missing latitude"}} )
	elseif args[4] == "" and args[5] == "" and args[6] == "" then
		-- dec logic
		result, errors = parseDec( args[1], args[2], args['format'] )
		if result == nil then
			return errorPrinter( errors );
		end			  
		result.param	= table.concat( {args[1], "_N_", args[2], "_E_", args[3] } );
	elseif dmsTest(args[4], args[8]) then
		-- dms logic
		result, errors = parseDMS( args[1], args[2], args[3], args[4], 
			args[5], args[6], args[7], args[8], args['format'] )
		result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
			args[6], args[7], args[8], args[9] } , '_' );
		if args[10] ~= '' then
			table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
		end		
	elseif dmsTest(args[3], args[6]) then
		-- dm logic
		result, errors = parseDMS( args[1], args[2], nil, args[3], 
			args[4], args[5], nil, args[6], args['format'] )
		result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
			args[6], args[7] } , '_' );
		if args[8] ~= '' then
			table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
		end		
	elseif dmsTest(args[2], args[4]) then
		-- d logic
		result, errors = parseDMS( args[1], nil, nil, args[2], 
			args[3], nil, nil, args[4], args['format'] )
		result.param = table.concat( { args[1], args[2], args[3], args[4], args[5] } , '_' );
		if args[6] ~= '' then
			table.insert( errors, { 'formatTest', 'Extra unexpected parameters' } );
		end		
	else
		-- Error
		return errorPrinter( {{"formatTest", "Unknown argument format"}} )
	end
	result.name	 = args["name"]
	
	local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
	for _, v in ipairs( extra_param ) do
		if (args[v] or '') ~= '' then 
			table.insert( errors, {'formatTest', 'Parameter: "' .. v .. '=" should be "' .. v .. ':"' } );
		end
	end
	
	if #errors == 0 then
		return specPrinter( args, result )	
	else
		return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '[[Category:Pages with malformed coordinate tags]]'; 
	end	
end

--[[ 
Helper function, convert decimal latitude or longitude to 
degrees, minutes, and seconds format based on the specified precision.  
]]
function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
	local coord = tonumber(coordinate) or 0
	local postfix
	if coord >= 0 then
		postfix = firstPostfix
	else
		postfix = secondPostfix
	end

	precision = precision:lower();
	if precision == "dms" then
		return convert_dec2dms_dms( math.abs( coord ) ) .. postfix;
	elseif precision == "dm" then
		return convert_dec2dms_dm( math.abs( coord ) ) .. postfix;
	elseif precision == "d" then
		return convert_dec2dms_d( math.abs( coord ) ) .. postfix;
	end
end

--[[ Helper function, convert decimal to degrees ]]
function convert_dec2dms_d(coordinate)
	local d = math_mod._round( coordinate, 0 ) .. "°"
	return d .. ""
end

--[[ Helper function, convert decimal to degrees and minutes ]]
function convert_dec2dms_dm(coordinate)	
	coordinate = math_mod._round( coordinate * 60, 0 );
	local m = coordinate % 60;
	coordinate = math.floor( (coordinate - m) / 60 );
	local d = coordinate % 360 .."°"
	
	return d .. string.format( "%02d′", m )
end

--[[ Helper function, convert decimal to degrees, minutes, and seconds ]]
function convert_dec2dms_dms(coordinate)
	coordinate = math_mod._round( coordinate * 60 * 60, 0 );
	local s = coordinate % 60
	coordinate = math.floor( (coordinate - s) / 60 );
	local m = coordinate % 60
	coordinate = math.floor( (coordinate - m) / 60 );
	local d = coordinate % 360 .."°"

	return d .. string.format( "%02d′", m ) .. string.format( "%02d″", s )
end

--[[
Convert DMS format into a N or E decimal coordinate
]]
function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
	local degrees = tonumber(degrees_str) or 0
	local minutes = tonumber(minutes_str) or 0
	local seconds = tonumber(seconds_str) or 0
	
	local factor = 1
	direction = mw.ustring.gsub(direction, '^[ ]*(.-)[ ]*$', '%1');
	if direction == "S" or direction == "W" then
		factor = -1
	end
	
	local precision = 0
	if seconds_str ~= nil and seconds_str ~= '' then
		precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
	elseif minutes_str ~= nil and minutes_str ~= '' then
		precision = 3 + math.max( math_mod._precision(minutes_str), 0 );
	else
		precision = math.max( math_mod._precision(degrees_str), 0 );
	end
	
	local decimal = factor * (degrees+(minutes+seconds/60)/60) 
	return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
end

--[[ 
Checks input values to for out of range errors.
]]
function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
	local errors = {};
	lat_d = tonumber( lat_d ) or 0;
	lat_m = tonumber( lat_m ) or 0;
	lat_s = tonumber( lat_s ) or 0;
	long_d = tonumber( long_d ) or 0;
	long_m = tonumber( long_m ) or 0;
	long_s = tonumber( long_s ) or 0;

	if strong then
		if lat_d < 0 then
			table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
		end
		if long_d < 0 then
			table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
		end
		--[[ 
		#coordinates is inconsistent about whether this is an error.  If globe: is
		specified, it won't error on this condition, but otherwise it will.
		
		For not simply disable this check.
		
		if long_d > 180 then
			table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
		end
		]]
	end	
		
	if lat_d > 90 then
		table.insert(errors, {source, "latitude degrees > 90"})
	end
	if lat_d < -90 then
		table.insert(errors, {source, "latitude degrees < -90"})
	end
	if lat_m >= 60 then
		table.insert(errors, {source, "latitude minutes >= 60"})
	end
	if lat_m < 0 then
		table.insert(errors, {source, "latitude minutes < 0"})
	end
	if lat_s >= 60 then
		table.insert(errors, {source, "latitude seconds >= 60"})
	end
	if lat_s < 0 then
		table.insert(errors, {source, "latitude seconds < 0"})
	end
	if long_d >= 360 then
		table.insert(errors, {source, "longitude degrees >= 360"})
	end
	if long_d <= -360 then
		table.insert(errors, {source, "longitude degrees <= -360"})
	end
	if long_m >= 60 then
		table.insert(errors, {source, "longitude minutes >= 60"})
	end
	if long_m < 0 then
		table.insert(errors, {source, "longitude minutes < 0"})
	end
	if long_s >= 60 then
		table.insert(errors, {source, "longitude seconds >= 60"})
	end
	if long_s < 0 then
		table.insert(errors, {source, "longitude seconds < 0"})
	end
	
	return errors;
end

--[[
link

Simple function to export the coordinates link for other uses.

Usage:
	{{ Invoke:Coordinates | link }}
	
]]
function coordinates.link(frame)
	return coord_link;
end

--[[
dec2dms

Wrapper to allow templates to call dec2dms directly.

Usage:
	{{ Invoke:Coordinates | dec2dms | decimal_coordinate | positive_suffix | 
		negative_suffix | precision }}
	
decimal_coordinate is converted to DMS format.  If positive, the positive_suffix
is appended (typical N or E), if negative, the negative suffix is appended.  The
specified precision is one of 'D', 'DM', or 'DMS' to specify the level of detail
to use.
]]
function coordinates.dec2dms(frame)
	globalFrame = frame
	local coordinate = frame.args[1]
	local firstPostfix = frame.args[2]
	local secondPostfix = frame.args[3]
	local precision = frame.args[4]

	return convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
end

--[[
Helper function to determine whether to use D, DM, or DMS
format depending on the precision of the decimal input.
]]
function coordinates.determineMode( value1, value2 )
	local precision = math.max( math_mod._precision( value1 ), math_mod._precision( value2 ) );
	if precision <= 0 then
		return 'd'
	elseif precision <= 2 then
		return 'dm';
	else
		return 'dms';
	end
end		

--[[
dms2dec

Wrapper to allow templates to call dms2dec directly.

Usage:
	{{ Invoke:Coordinates | dms2dec | direction_flag | degrees | 
		minutes | seconds }}
	
Converts DMS values specified as degrees, minutes, seconds too decimal format.
direction_flag is one of N, S, E, W, and determines whether the output is 
positive (i.e. N and E) or negative (i.e. S and W).
]]
function coordinates.dms2dec(frame)
	globalFrame = frame
	local direction = frame.args[1]
	local degrees = frame.args[2]
	local minutes = frame.args[3]
	local seconds = frame.args[4]

	return convert_dms2dec(direction, degrees, minutes, seconds)
end

--[[
coord

Main entry point for Lua function to replace {{coord}}

Usage:
	{{ Invoke:Coordinates | coord }}
	{{ Invoke:Coordinates | coord | lat | long }}
	{{ Invoke:Coordinates | coord | lat | lat_flag | long | long_flag }}
	...
	
	Refer to {{coord}} documentation page for many additional parameters and 
	configuration options.
	
Note: This function provides the visual display elements of {{coord}}.  In
order to load coordinates into the database, the {{#coordinates:}} parser 
function must also be called, this is done automatically in the Lua
version of {{coord}}.
]]
function coordinates.coord(frame)
	globalFrame = frame
	local args = frame.args
	if args[1] == nil then
		local pFrame = frame:getParent();
		args = pFrame.args;
		for k,v in pairs( frame.args ) do
			args[k] = v;
		end
	end
	
	for i=1,10 do 
		if args[i] == nil then 
			args[i] = ""
		else
			args[i] = args[i]:match( '^%s*(.-)%s*$' );  --remove whitespace
		end		
	end
	args['format'] = args['format'] or '';
	
	local contents = formatTest(args)
	local Notes = args.notes or ""
	local Display = string.lower(args.display or "inline")
	if Display == '' then
		Display = 'inline';
	end
	
	local text = ''
	local valid_Display = false
	if string.find( Display, 'inline' ) ~= nil or Display == 'i' or 
			Display == 'it' or Display == 'ti' then
		text = displayinline(contents, Notes)
		valid_Display = true
	end
	if string.find( Display, 'title' ) ~= nil or Display == 't' or 
			Display == 'it' or Display == 'ti' then
		text = text .. displaytitle(contents, Notes)
		valid_Display = true
	end
	local wikidata_cat
	if valid_Display and mw.wikibase and current_page.namespace == 0 then -- add the appropriate Wikidata category for main namespace pages
		local entity = mw.wikibase.getEntity()
		if entity and entity.claims.p625 then
			local snaktype = entity.claims.p625[0].mainsnak.snaktype
			if snaktype == 'value' then
				wikidata_cat = '[[Category:Coordinates on Wikidata]]' -- coordinates exist both here and on Wikidata, and can be compared
			elseif snaktype == 'somevalue' then
				wikidata_cat = '[[Category:Coordinates on Wikidata set to unknown value]]'
			elseif snaktype == 'novalue' then
				wikidata_cat = '[[Category:Coordinates on Wikidata set to no value]]'
			end
		else
			wikidata_cat = '[[Category:Coordinates not on Wikidata]]' -- we have to either import the coordinates to Wikidata or remove them here
		end
	end
	wikidata_cat = wikidata_cat or ''
	text = text .. wikidata_cat
	return text
end

return coordinates