ویکی حج

پودمان:Coordinates: تفاوت میان نسخه‌ها

پودمان بحث

پودمان:Coordinates (ویرایش)

نسخهٔ ‏۶ ژوئیهٔ ۲۰۱۹، ساعت ۰۷:۳۵

۲٬۷۴۲ بایت اضافه‌شده ،  ‏۶ ژوئیهٔ ۲۰۱۹
self-rv: Johnuniq wanted to remove namespace test for both category and error output. Also looks like he explicitly removed a bunch whitespace.
(صفحه‌ای تازه حاوی «--[[ جایگزین الگوی مختصات This module is intended to replace the functionality of {{Coord}} and related templates. It p...» ایجاد کرد)
 
(self-rv: Johnuniq wanted to remove namespace test for both category and error output. Also looks like he explicitly removed a bunch whitespace.)
خط ۱: خط ۱:
--[[
--[[
جایگزین الگوی مختصات
This module is intended to replace the functionality of {{Coord}} and related
This module is intended to replace the functionality of {{Coord}} and related
templates.  It provides several methods, including
templates.  It provides several methods, including


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


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


{{#Invoke:Coordinates | dms2dec }} : Simple function for converting DMS format
{{#invoke:Coordinates | dms2dec }} : Simple function for converting DMS format
to decimal degree format.
to decimal degree format.
{{#invoke:Coordinates | link }} : Export the link used to reach the tools


]]
]]


math_mod = require( "Module:Math" );
require('Module:No globals')
numeral_converter = require( "Module:Numeral converter" );
 
globalFrame = nil
local math_mod = require("Module:Math")
local coordinates = {};


coordinates = {};
local current_page = mw.title.getCurrentTitle()
local page_name = mw.uri.encode( current_page.prefixedText, 'WIKI' );
local 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)
local function displaytitle(s, notes)
    local l = "[[دستگاه مختصات جغرافیایی|مختصات]]: " .. 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)
local 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 function dmsTest(first, second)
    local concatenated = first:upper() .. second:upper();
if type(first) ~= 'string' or type(second) ~= 'string' then
 
return nil
    if concatenated == "NE" or concatenated == "NW" or concatenated == "SE" or concatenated == "SW" or
end
        concatenated == "EN" or concatenated == "WN" or concatenated == "ES" or concatenated == "WS" then
local s = (first .. second):upper()
        return true;
return s:find('^[NS][EW]$') or s:find('^[EW][NS]$')
    end
    return false;
end
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", "طول جغرافیایی وارد نشده است"}}
    end


    errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );
--[[ Wrapper function to grab args, see Module:Arguments for this function's documentation. ]]
    coordinateSpec["dec-lat"] = lat;
local function makeInvokeFunc(funcName)
    coordinateSpec["dec-long"] = long;
return function (frame)
 
local args = require('Module:Arguments').getArgs(frame, {
    local mode = coordinates.determineMode( lat, long );
wrappers = 'Template:Coord'
    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}}}}}}}
return coordinates[funcName](args, frame)
 
end
    if format ~= "" then
        coordinateSpec.default = format
    else
        coordinateSpec.default = "dec"
    end
 
    return coordinateSpec, errors
end
end


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


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


    lat_f = lat_f:upper();
--[[
    long_f = long_f:upper();
Determine the required CSS class to display coordinates


    -- Check if specified backward
Usually geo-nondefault is hidden by CSS, unless a user has overridden this for himself
    if lat_f == 'E' or lat_f == 'W' then
default is the mode as specificied by the user when calling the {{coord}} template
        local t_d, t_m, t_s, t_f;
mode is the display mode (dec or dms) that we will need to determine the css class for
        t_d = lat_d;
]]
        t_m = lat_m;
local function displayDefault(default, mode)
        t_s = lat_s;
if default == "" then
        t_f = lat_f;
default = "dec"
        lat_d = long_d;
end
        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", "طول جغرافیایی وارد نشده است" })
    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
if default == mode then
return "geo-default"
else
return "geo-nondefault"
end
end
end


خط ۱۵۲: خط ۹۹:
or parseDMS and formats it for inclusion on Wikipedia.
or parseDMS and formats it for inclusion on Wikipedia.
]]
]]
function specPrinter(args, coordinateSpec)
local 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 "خطا: پارامتر خالی است"
return "ERROR param was empty"
    end
end
    if args["name"] ~= "" and args["name"] ~= nil then
if args["name"] 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">'
.. '<span class="latitude">' .. coordinateSpec["dms-lat"] .. '</span> '
.. '<span class="longitude">' ..coordinateSpec["dms-long"] .. '</span>'
.. '</span>'


    local dms_lat = numeral_converter.convert( "fa", coordinateSpec["dms-lat"] )
local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
    dms_lat = mw.ustring.gsub(dms_lat, "(.-)N", '<span dir="ltr">%1</span> شمالی')
local geodeclat
    dms_lat = mw.ustring.gsub(dms_lat, "(.-)S", '<span dir="ltr">%1</span> جنوبی')
if lat < 0 then
-- FIXME this breaks the pre-existing precision
geodeclat = tostring(coordinateSpec["dec-lat"]):sub(2) .. "°S"
else
geodeclat = (coordinateSpec["dec-lat"] or 0) .. "°N"
end


    local dms_long = numeral_converter.convert( "fa", coordinateSpec["dms-long"] )
local long = tonumber( coordinateSpec["dec-long"] ) or 0
    dms_long = mw.ustring.gsub(dms_long, "(.-)E", '<span dir="ltr">%1</span> شرقی')
local geodeclong
    dms_long = mw.ustring.gsub(dms_long, "(.-)W", '<span dir="ltr">%1</span> غربی')
if long < 0 then
-- FIXME does not handle unicode minus
geodeclong = tostring(coordinateSpec["dec-long"]):sub(2) .. "°W"
else
geodeclong = (coordinateSpec["dec-long"] or 0) .. "°E"
end


    local geodmshtml = '<span class="geo-dms" title="نقشه‌ها، عکس‌های هوایی و اطلاعات دیگر برای این مکان">'
local geodechtml = '<span class="geo-dec" title="Maps, aerial photos, and other data for this location">'
            .. '<span class="latitude">' .. dms_lat .. '</span> '
.. geodeclat .. ' '
            .. '<span class="longitude">' .. dms_long .. '</span>'
.. geodeclong
            .. '</span>'
.. '</span>'


    local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
local geonumhtml = '<span class="geo">'
    if lat < 0 then
.. coordinateSpec["dec-lat"] .. '; '
        -- FIXME this breaks the pre-existing precision
.. coordinateSpec["dec-long"]
        geodeclat = '<span dir="ltr">' .. numeral_converter.convert( "fa", coordinateSpec["dec-lat"]:sub(2) ) .. "°</span> جنوبی"
.. '</span>'
    else
        geodeclat = '<span dir="ltr">' .. numeral_converter.convert( "fa", (coordinateSpec["dec-lat"] or 0) ) .. "°</span> شمالی"
    end


    local long = tonumber( coordinateSpec["dec-long"] ) or 0
local inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
    if long < 0 then
.. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
        -- FIXME does not handle unicode minus
.. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';
        geodeclong = '<span dir="ltr">' .. numeral_converter.convert( "fa", coordinateSpec["dec-long"]:sub(2) ) .. "°</span> غربی"
    else
        geodeclong = '<span dir="ltr">' .. numeral_converter.convert( "fa", (coordinateSpec["dec-long"] or 0) ) .. "°</span> شرقی"
    end


    local geodechtml = '<span class="geo-dec" title="نقشه‌ها، عکس‌های هوایی و اطلاعات دیگر برای این مکان">'
if not args["name"] then
            .. geodeclat .. ' '
inner = inner .. geodechtml
            .. geodeclong
.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></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
 
--[[ Helper function, convert decimal to degrees ]]
local function convert_dec2dms_d(coordinate)
local d = math_mod._round( coordinate, 0 ) .. "°"
return d .. ""
end


    local geonumhtml = '<span class="geo">'
--[[ Helper function, convert decimal to degrees and minutes ]]
            .. coordinateSpec["dec-lat"] .. '; '
local function convert_dec2dms_dm(coordinate)
            .. coordinateSpec["dec-long"]
coordinate = math_mod._round( coordinate * 60, 0 );
            .. '</span>'
local m = coordinate % 60;
coordinate = math.floor( (coordinate - m) / 60 );
local d = coordinate % 360 .."°"


    local inner;
return d .. string.format( "%02d′", m )
    inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
end
                .. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
                .. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';


    if args["name"] == "" or args["name"] == nil then
--[[ Helper function, convert decimal to degrees, minutes, and seconds ]]
        inner = inner .. geodechtml
local function convert_dec2dms_dms(coordinate)
                .. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></span>'
coordinate = math_mod._round( coordinate * 60 * 60, 0 );
    else
local s = coordinate % 60
        inner = inner .. '<span class="vcard">' .. geodechtml
coordinate = math.floor( (coordinate - s) / 60 );
                .. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span>'
local m = coordinate % 60
                .. '<span style="display:none">&#xfeff; (<span class="fn org">'
coordinate = math.floor( (coordinate - m) / 60 );
                .. args["name"] .. '</span>)</span></span></span>'
local d = coordinate % 360 .."°"
    end


    return '<span class="plainlinks nourlexpansion">' .. globalFrame:preprocess(
return d .. string.format( "%02d′", m ) .. string.format( "%02d″", s )
        '[//tools.wmflabs.org/geohack/geohack.php?pagename={{FULLPAGENAMEE}}&language=fa&params=' ..
        uriComponents .. ' ' .. inner .. ']') .. '</span>'
end
end


--[[
--[[
Formats any error messages generated for display
Helper function, convert decimal latitude or longitude to
degrees, minutes, and seconds format based on the specified precision.
]]
]]
function errorPrinter(errors)
local function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
    local result = ""
local coord = tonumber(coordinate)
    for i,v in ipairs(errors) do
local postfix
        local errorHTML = '<strong class="error">مختصات‌ها: ' .. v[2] .. '</strong>'
if coord >= 0 then
        result = result .. errorHTML .. "<br />"
postfix = firstPostfix
    end
else
    return result
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
end


--[[
--[[
Determine the required CSS class to display coordinates
Convert DMS format into a N or E decimal coordinate
]]
local function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
local degrees = tonumber(degrees_str)
local minutes = tonumber(minutes_str) or 0
local seconds = tonumber(seconds_str) or 0
 
local factor = 1
if direction == "S" or direction == "W" then
factor = -1
end
 
local precision = 0
if seconds_str then
precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
elseif minutes_str 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


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
Checks input values to for out of range errors.
mode is the display mode (dec or dms) that we will need to determine the css class for
]]
]]
function displayDefault(default, mode)
local function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
    if default == "" then
local errors = {};
        default = "dec"
lat_d = tonumber( lat_d ) or 0;
    end
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 default == mode then
if strong then
        return "geo-default"
if lat_d < 0 then
    else
table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
        return "geo-nondefault"
end
    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
end


--[[
--[[
Check the input arguments for coord to determine the kind of data being provided
parseDec
and then make the necessary processing.
 
Transforms decimal format latitude and longitude into the
structure to be used in displaying coordinates
]]
]]
function formatTest(args)
local function parseDec( lat, long, format )
    local result, errors;
local coordinateSpec = {}
    local primary = false;
local errors = {}
 
if not long then
return nil, {{"parseDec", "Missing longitude"}}
elseif not tonumber(long) then
return nil, {{"parseDec", "Longitude could not be parsed as a number: " .. long}}
end
 
errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );
coordinateSpec["dec-lat"]  = lat;
coordinateSpec["dec-long"] = long;


    if args[1] == "" then
local mode = coordinates.determineMode( lat, long );
        -- no lat logic
coordinateSpec["dms-lat"] = convert_dec2dms( lat, "N", "S", mode) -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
        return errorPrinter( {{"formatTest", "عرض جغرافیایی وارد نشده است"}} )
coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode) -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
    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', 'پارامترهای اضافی وارد شده است' } );
        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', 'پارامترهای اضافی وارد شده است' } );
        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', 'پارامترهای اضافی وارد شده است' } );
        end
    else
        -- Error
        return errorPrinter( {{"formatTest", "قالب آرگومان ناشناخته است"}} )
    end
    result.name    = args["name"]


    local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
if format then
    for _, v in ipairs( extra_param ) do
coordinateSpec.default = format
        if (args[v] or '') ~= '' then
else
            table.insert( errors, {'formatTest', 'پارامتر: "' .. v .. '=" باید چنین باشد "' .. v .. ':"' } );
coordinateSpec.default = "dec"
        end
end
    end


    if #errors == 0 then
return coordinateSpec, errors
        return specPrinter( args, result )
    else
        return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '';
    end
end
end


--[[
--[[
Helper function, convert decimal latitude or longitude to
parseDMS
degrees, minutes, and seconds format based on the specified precision.
 
Transforms degrees, minutes, seconds format latitude and longitude
into the a structure to be used in displaying coordinates
]]
]]
function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
local function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
    local coord = tonumber(coordinate) or 0
local coordinateSpec, errors, backward = {}, {}
    local postfix
 
    if coord >= 0 then
lat_f = lat_f:upper();
        postfix = firstPostfix
long_f = long_f:upper();
    else
        postfix = secondPostfix
    end


    precision = precision:lower();
-- Check if specified backward
    if precision == "dms" then
if lat_f == 'E' or lat_f == 'W' then
        return convert_dec2dms_dms( math.abs( coord ) ) .. postfix;
lat_d, long_d, lat_m, long_m, lat_s, long_s, lat_f, long_f, backward = long_d, lat_d, long_m, lat_m, long_s, lat_s, long_f, lat_f, true;
    elseif precision == "dm" then
end
        return convert_dec2dms_dm( math.abs( coord ) ) .. postfix;
 
    elseif precision == "d" then
errors = validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, 'parseDMS', true );
        return convert_dec2dms_d( math.abs( coord ) ) .. postfix;
if not long_d then
    end
return nil, {{"parseDMS", "Missing longitude" }}
end
elseif not tonumber(long_d) then
return nil, {{"parseDMS", "Longitude could not be parsed as a number:" .. long_d }}
end


--[[ Helper function, convert decimal to degrees ]]
if not lat_m and not lat_s and not long_m and not long_s and #errors == 0 then
function convert_dec2dms_d(coordinate)
if math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
    local d = math_mod._round( coordinate, 0 ) .. "°"
if lat_f:upper() == 'S' then
    return d .. ""
lat_d = '-' .. lat_d;
end
end
if long_f:upper() == 'W' then
long_d = '-' .. long_d;
end


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


    return d .. string.format( "%02d′", m )
coordinateSpec["dms-lat"]  = lat_d.."°"..optionalArg(lat_m,"′") .. optionalArg(lat_s,"″") .. lat_f
end
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}}}}}


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


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


--[[
--[[
Convert DMS format into a N or E decimal coordinate
Check the input arguments for coord to determine the kind of data being provided
and then make the necessary processing.
]]
]]
function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
local function formatTest(args)
    local degrees = tonumber(degrees_str) or 0
local result, errors
    local minutes = tonumber(minutes_str) or 0
local backward, primary = false, false
    local seconds = tonumber(seconds_str) or 0


    local factor
local function getParam(args, lim)
    if direction == "N" or direction == "E" then
local ret = {}
        factor = 1
for i = 1, lim do
    else
ret[i] = args[i] or ''
        factor = -1
end
    end
return table.concat(ret, '_')
end


    local precision = 0
if not args[1] then
    if seconds_str ~= nil and seconds_str ~= '' then
-- no lat logic
        precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
return errorPrinter( {{"formatTest", "Missing latitude"}} )
    elseif minutes_str ~= nil and minutes_str ~= '' then
elseif not tonumber(args[1]) then
        precision = 3 + math.max( math_mod._precision(minutes_str), 0 );
-- bad lat logic
    else
return errorPrinter( {{"formatTest", "Unable to parse latitude as a number:" .. args[1]}} )
        precision = math.max( math_mod._precision(degrees_str), 0 );
elseif not args[4] and not args[5] and not args[6] then
    end
-- dec logic
result, errors = parseDec(args[1], args[2], args.format)
if not result then
return errorPrinter(errors);
end
-- formatting for geohack: geohack expects D_N_D_E notation or D;D notation
-- wikiminiatlas doesn't support D;D notation
-- #coordinates parserfunction doesn't support negative decimals with NSWE
result.param = table.concat({
math.abs(tonumber(args[1])),
((tonumber(args[1]) or 0) < 0) and 'S' or 'N',
math.abs(tonumber(args[2])),
((tonumber(args[2]) or 0) < 0) and 'W' or 'E',
args[3] or ''}, '_')
elseif dmsTest(args[4], args[8]) then
-- dms logic
result, errors, backward = parseDMS(args[1], args[2], args[3], args[4],
args[5], args[6], args[7], args[8], args.format)
if args[10] then
table.insert(errors, {'formatTest', 'Extra unexpected parameters'})
end
if not result then
return errorPrinter(errors)
end
result.param = getParam(args, 9)
elseif dmsTest(args[3], args[6]) then
-- dm logic
result, errors, backward = parseDMS(args[1], args[2], nil, args[3],
args[4], args[5], nil, args[6], args['format'])
if args[8] then
table.insert(errors, {'formatTest', 'Extra unexpected parameters'})
end
if not result then
return errorPrinter(errors)
end
result.param = getParam(args, 7)
elseif dmsTest(args[2], args[4]) then
-- d logic
result, errors, backward = parseDMS(args[1], nil, nil, args[2],
args[3], nil, nil, args[4], args.format)
if args[6] then
table.insert(errors, {'formatTest', 'Extra unexpected parameters'})
end
if not result then
return errorPrinter(errors)
end
result.param = getParam(args, 5)
else
-- Error
return errorPrinter({{"formatTest", "Unknown argument format"}})
end
result.name = args.name


    local decimal = factor * (degrees+(minutes+seconds/60)/60)
local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
    return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
for _, v in ipairs(extra_param) do
if args[v] then
table.insert(errors, {'formatTest', 'Parameter: "' .. v .. '=" should be "' .. v .. ':"' })
end
end
 
local ret = specPrinter(args, result)
if #errors > 0 then
ret = ret .. ' ' .. errorPrinter(errors) .. '[[Category:Pages with malformed coordinate tags]]'
end
return ret, backward
end
end


--[[
--[[
Checks input values to for out of range errors.
Generate Wikidata tracking categories.
]]
]]
function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
local function makeWikidataCategories(qid)
    local errors = {};
local ret
    lat_d = tonumber( lat_d ) or 0;
if mw.wikibase and current_page.namespace == 0 then
    lat_m = tonumber( lat_m ) or 0;
local entity = qid and mw.wikibase.getEntityObject(qid) or mw.wikibase.getEntityObject()
    lat_s = tonumber( lat_s ) or 0;
if entity and entity.claims and entity.claims.P625 and entity.claims.P625[1] then
    long_d = tonumber( long_d ) or 0;
local snaktype = entity.claims.P625[1].mainsnak.snaktype
    long_m = tonumber( long_m ) or 0;
if snaktype == 'value' then
    long_s = tonumber( long_s ) or 0;
-- coordinates exist both here and on Wikidata, and can be compared.
ret = 'Coordinates on Wikidata'
elseif snaktype == 'somevalue' then
ret = 'Coordinates on Wikidata set to unknown value'
elseif snaktype == 'novalue' then
ret = 'Coordinates on Wikidata set to no value'
end
else
-- We have to either import the coordinates to Wikidata or remove them here.
ret = 'Coordinates not on Wikidata'
end
end
if ret then
return string.format('[[Category:%s]]', ret)
else
return ''
end
end


    if strong then
--[[
        if lat_d < 0 then
link
            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.
Simple function to export the coordinates link for other uses.


        if long_d > 180 then
Usage:
            table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
{{#invoke:Coordinates | link }}
        end
        ]]
    end


    if lat_d > 90 then
]]
        table.insert(errors, {source, "latitude degrees > 90"})
function coordinates.link(frame)
    end
return coord_link;
    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
end


خط ۴۷۲: خط ۵۳۰:


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
خط ۴۸۰: خط ۵۳۸:
to use.
to use.
]]
]]
function coordinates.dec2dms(frame)
coordinates.dec2dms = makeInvokeFunc('_dec2dms')
    globalFrame = frame
function coordinates._dec2dms(args)
    local coordinate = numeral_converter.convert( "en", frame.args[1] )
local coordinate = args[1]
    local firstPostfix = numeral_converter.convert( "en", frame.args[2] )
local firstPostfix = args[2] or ''
    local secondPostfix = numeral_converter.convert( "en", frame.args[3] )
local secondPostfix = args[3] or ''
    local precision = numeral_converter.convert( "en", frame.args[4] )
local precision = args[4] or ''


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


خط ۴۹۵: خط ۵۵۳:
]]
]]
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


خط ۵۱۱: خط ۵۶۹:


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.
خط ۵۱۸: خط ۵۷۶:
positive (i.e. N and E) or negative (i.e. S and W).
positive (i.e. N and E) or negative (i.e. S and W).
]]
]]
function coordinates.dms2dec(frame)
coordinates.dms2dec = makeInvokeFunc('_dms2dec')
    globalFrame = frame
function coordinates._dms2dec(args)
    local direction = numeral_converter.convert( "en", frame.args[1] )
local direction = args[1]
    local degrees = numeral_converter.convert( "en", frame.args[2] )
local degrees = args[2]
    local minutes = numeral_converter.convert( "en", frame.args[3] )
local minutes = args[3]
    local seconds = numeral_converter.convert( "en", frame.args[4] )
local seconds = args[4]


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


خط ۵۳۴: خط ۵۹۲:


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
خط ۵۴۷: خط ۶۰۵:
version of {{coord}}.
version of {{coord}}.
]]
]]
function coordinates.coord(frame)
coordinates.coord = makeInvokeFunc('_coord')
    globalFrame = frame
function coordinates._coord(args)
    local args = frame.args
if not tonumber(args[1]) and not args[2] then
    if args[1] == nil then
args[3] = args[1]; args[1] = nil
        local pFrame = frame:getParent();
local entity = mw.wikibase.getEntityObject(args.qid)
        args = pFrame.args;
if entity
        for k,v in pairs( frame.args ) do
and entity.claims
            args[k] = numeral_converter.convert( "en", v );
and entity.claims.P625
        end
and entity.claims.P625[1].mainsnak.snaktype == 'value'
    end
then
local precision = entity.claims.P625[1].mainsnak.datavalue.value.precision
args[1] = entity.claims.P625[1].mainsnak.datavalue.value.latitude
args[2] = entity.claims.P625[1].mainsnak.datavalue.value.longitude
if precision then
precision = -math_mod._round(math.log(precision)/math.log(10),0)
args[1] = math_mod._round(args[1],precision)
args[2] = math_mod._round(args[2],precision)
end
end
end
 
local contents, backward = formatTest(args)
local Notes = args.notes or ''
local Display = args.display and args.display:lower() or 'inline'
 
local function isInline(s)
-- Finds whether coordinates are displayed inline.
return s:find('inline') ~= nil or s == 'i' or s == 'it' or s == 'ti'
end
local function isInTitle(s)
-- Finds whether coordinates are displayed in the title.
return s:find('title') ~= nil or s == 't' or s == 'it' or s == 'ti'
end
 
local function coord_wrapper(in_args)
-- Calls the parser function {{#coordinates:}}.
return mw.getCurrentFrame():callParserFunction('#coordinates', in_args) or ''
end


    for i=1,10 do
local text = ''
        if args[i] == nil then
if isInline(Display) then
            args[i] = ""
text = text .. displayinline(contents, Notes)
        else
end
            args[i] = numeral_converter.convert( "en", args[i]:match( '^%s*(.-)%s*$' ) );
if isInTitle(Display) then
              -- converting to English and remove whitespaces
text = text
        end
.. displaytitle(contents, Notes)
    end
.. makeWikidataCategories(args.qid)
    args['format'] = args['format'] or '';
end
if not args.nosave then
local page_title, count = mw.title.getCurrentTitle(), 1
if backward then
local tmp = {}
while not string.find((args[count-1] or ''), '[EW]') do tmp[count] = (args[count] or ''); count = count+1 end
tmp.count = count; count = 2*(count-1)
while count >= tmp.count do table.insert(tmp, 1, (args[count] or '')); count = count-1 end
for i, v in ipairs(tmp) do args[i] = v end
else
while count <= 9 do args[count] = (args[count] or ''); count = count+1 end
end
if isInTitle(Display) and not page_title.isTalkPage and page_title.subpageText ~= 'doc' and page_title.subpageText ~= 'testcases' then args[10] = 'primary' end
args.notes, args.format, args.display = nil
text = text .. coord_wrapper(args)
end
return text
end


    local contents = formatTest(args)
--[[
    local Notes = args.notes or ""
coord2text
    local Display = string.lower(args.display or "inline")
    if Display == '' then
        Display = 'inline';
    end


     local text = ''
Extracts a single value from a transclusion of {{Coord}}.
    if string.find( Display, 'inline' ) ~= nil or Display == 'i' or
IF THE GEOHACK LINK SYNTAX CHANGES THIS FUNCTION MUST BE MODIFIED.
            Display == 'it' or Display == 'ti' then
 
        text = displayinline(contents, Notes)
Usage:
    end
 
     if string.find( Display, 'title' ) ~= nil or Display == 't' or
     {{#invoke:Coordinates | coord2text | {{Coord}} | parameter }}
            Display == 'it' or Display == 'ti' then
 
        text = text .. displaytitle(contents, Notes)
Valid values for the second parameter are: lat (signed integer), long (signed integer), type, scale, dim, region, globe, source
    end
 
    return text
]]
function coordinates.coord2text(frame)
if frame.args[1] == '' or frame.args[2] == '' or not frame.args[2] then return nil end
frame.args[2] = mw.text.trim(frame.args[2])
if frame.args[2] == 'lat' or frame.args[2] == 'long' then
local result, negative = mw.text.split((mw.ustring.match(frame.args[1],'[%.%d]+°[NS] [%.%d]+°[EW]') or ''), ' ')
if frame.args[2] == 'lat' then
result, negative = result[1], 'S'
else
result, negative = result[2], 'W'
end
result = mw.text.split(result, '°')
if result[2] == negative then result[1] = '-'..result[1] end
return result[1]
else
return mw.ustring.match(frame.args[1], 'params=.-_'..frame.args[2]..':(.-)[ _]')
end
end
 
--[[
coordinsert
 
Injects some text into the Geohack link of a transclusion of {{Coord}} (if that text isn't already in the transclusion). Outputs the modified transclusion of {{Coord}}.
IF THE GEOHACK LINK SYNTAX CHANGES THIS FUNCTION MUST BE MODIFIED.
 
Usage:
 
     {{#invoke:Coordinates | coordinsert | {{Coord}} | parameter:value | parameter:value | … }}
 
Do not make Geohack unhappy by inserting something which isn't mentioned in the {{Coord}} documentation.
 
]]
function coordinates.coordinsert(frame)
for i, v in ipairs(frame.args) do
if i ~= 1 then
if not mw.ustring.find(frame.args[1], (mw.ustring.match(frame.args[i], '^(.-:)') or '')) then
frame.args[1] = mw.ustring.gsub(frame.args[1], '(params=.-)_? ', '%1_'..frame.args[i]..' ')
end
end
end
if frame.args.name then
if not mw.ustring.find(frame.args[1], '<span class="vcard">') then
local namestr = frame.args.name
frame.args[1] = mw.ustring.gsub(frame.args[1],
'(<span class="geo%-default">)(<span[^<>]*>[^<>]*</span><span[^<>]*>[^<>]*<span[^<>]*>[^<>]*</span></span>)(</span>)',
'%1<span class="vcard">%2<span style="display:none">&#xfeff; (<span class="fn org">' .. namestr .. '</span>)</span></span>%3')
frame.args[1] = mw.ustring.gsub(frame.args[1], '(&params=[^&"<>%[%] ]*) ', '%1&title=' .. mw.uri.encode(namestr) .. ' ')
end
end
return frame.args[1]
end
end


return coordinates
return coordinates
کاربر ناشناس
برگرفته از «https://wikihaj.com/view/ویژه:تفاوت_گوشی_همراه/28981»