در حال ویرایش پودمان:Coordinates

هشدار: شما وارد نشده‌اید. نشانی آی‌پی شما برای عموم قابل مشاهده خواهد بود اگر هر تغییری ایجاد کنید. اگر وارد شوید یا یک حساب کاربری بسازید، ویرایش‌هایتان به نام کاربری‌تان نسبت داده خواهد شد، همراه با مزایای دیگر.

این ویرایش را می‌توان خنثی کرد. لطفاً تفاوت زیر را بررسی کنید تا تأیید کنید که این چیزی است که می‌خواهید انجام دهید، سپس تغییرات زیر را ذخیره کنید تا خنثی‌سازی ویرایش را به پایان ببرید.

نسخهٔ فعلی متن شما
خط ۱: خط ۱:
--[[
--[[
جایگزین الگوی مختصات
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


]]
]]


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


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


--[[ Wrapper function to grab args, see Module:Arguments for this function's documentation. ]]
    errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );
local function makeInvokeFunc(funcName)
    coordinateSpec["dec-lat"] = lat;
return function (frame)
    coordinateSpec["dec-long"] = long;
local args = require('Module:Arguments').getArgs(frame, {
 
wrappers = 'Template:Coord'
    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}}}}}}}
return coordinates[funcName](args, frame)
    coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode) -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
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. ]]
local function optionalArg(arg, supplement)
function optionalArg(arg, suplement)
return arg and arg .. supplement or ''
    if arg ~= nil and arg ~= "" then
        return arg .. suplement
    end
    return ""
end
end


--[[
--[[
Formats any error messages generated for display
parseDMS
 
Transforms degrees, minutes, seconds format latitude and longitude
into the a structure to be used in displaying coordinates
]]
]]
local function errorPrinter(errors)
function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
local result = ""
    local coordinateSpec = {}
for i,v in ipairs(errors) do
    local errors = {}
local errorHTML = '<strong class="error">Coordinates: ' .. v[2] .. '</strong>'
 
result = result .. errorHTML .. "<br />"
    lat_f = lat_f:upper();
end
    long_f = long_f:upper();
return result
 
end
    -- 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", "طول جغرافیایی وارد نشده است" })
    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
Determine the required CSS class to display coordinates
    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}}}}}


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


if default == mode then
    return coordinateSpec, errors
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.
]]
]]
local 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 "خطا: پارامتر خالی است"
end
    end
if args["name"] 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">'
.. '<span class="latitude">' .. coordinateSpec["dms-lat"] .. '</span> '
.. '<span class="longitude">' ..coordinateSpec["dms-long"] .. '</span>'
.. '</span>'


local lat = tonumber( coordinateSpec["dec-lat"] ) or 0
    local dms_lat = numeral_converter.convert( "fa", coordinateSpec["dms-lat"] )
local geodeclat
    dms_lat = mw.ustring.gsub(dms_lat, "(.-)N", '<span dir="ltr">%1</span> شمالی')
if lat < 0 then
    dms_lat = mw.ustring.gsub(dms_lat, "(.-)S", '<span dir="ltr">%1</span> جنوبی')
-- 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 long = tonumber( coordinateSpec["dec-long"] ) or 0
    local dms_long = numeral_converter.convert( "fa", coordinateSpec["dms-long"] )
local geodeclong
    dms_long = mw.ustring.gsub(dms_long, "(.-)E", '<span dir="ltr">%1</span> شرقی')
if long < 0 then
    dms_long = mw.ustring.gsub(dms_long, "(.-)W", '<span dir="ltr">%1</span> غربی')
-- FIXME does not handle unicode minus
geodeclong = tostring(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">'
    local geodmshtml = '<span class="geo-dms" title="نقشه‌ها، عکس‌های هوایی و اطلاعات دیگر برای این مکان">'
.. geodeclat .. ' '
            .. '<span class="latitude">' .. dms_lat .. '</span> '
.. geodeclong
            .. '<span class="longitude">' .. dms_long .. '</span>'
.. '</span>'
            .. '</span>'


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


local inner = '<span class="' .. displayDefault(coordinateSpec["default"], "dms" ) .. '">' .. geodmshtml .. '</span>'
    local long = tonumber( coordinateSpec["dec-long"] ) or 0
.. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
    if long < 0 then
.. '<span class="' .. displayDefault(coordinateSpec["default"], "dec" ) .. '">';
        -- FIXME does not handle unicode minus
        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


if not args["name"] then
    local geodechtml = '<span class="geo-dec" title="نقشه‌ها، عکس‌های هوایی و اطلاعات دیگر برای این مکان">'
inner = inner .. geodechtml
            .. geodeclat .. ' '
.. '<span style="display:none">&#xfeff; / ' .. geonumhtml .. '</span></span>'
            .. geodeclong
else
            .. '</span>'
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


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


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


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


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


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


--[[
--[[
Convert DMS format into a N or E decimal coordinate
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
]]
]]
local function convert_dms2dec(direction, degrees_str, minutes_str, seconds_str)
function displayDefault(default, mode)
local degrees = tonumber(degrees_str)
    if default == "" then
local minutes = tonumber(minutes_str) or 0
        default = "dec"
local seconds = tonumber(seconds_str) or 0
    end
 
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)
    if default == mode then
return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
        return "geo-default"
    else
        return "geo-nondefault"
    end
end
end


--[[
--[[
Checks input values to for out of range errors.
Check the input arguments for coord to determine the kind of data being provided
and then make the necessary processing.
]]
]]
local function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
function formatTest(args)
local errors = {};
    local result, errors;
lat_d = tonumber( lat_d ) or 0;
    local primary = false;
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 args[1] == "" then
if lat_d < 0 then
        -- no lat logic
table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
        return errorPrinter( {{"formatTest", "عرض جغرافیایی وارد نشده است"}} )
end
    elseif args[4] == "" and args[5] == "" and args[6] == "" then
if long_d < 0 then
        -- dec logic
table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
        result, errors = parseDec( args[1], args[2], args['format'] )
end
        if result == nil then
--[[
            return errorPrinter( errors );
#coordinates is inconsistent about whether this is an error. If globe: is
        end
specified, it won't error on this condition, but otherwise it will.
        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"]


For not simply disable this check.
    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', 'پارامتر: "' .. v .. '=" باید چنین باشد "' .. v .. ':"' } );
        end
    end


if long_d > 180 then
    if #errors == 0 then
table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
        return specPrinter( args, result )
end
    else
]]
        return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '';
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


--[[
--[[
parseDec
Helper function, convert decimal latitude or longitude to
 
degrees, minutes, and seconds format based on the specified precision.
Transforms decimal format latitude and longitude into the
structure to be used in displaying coordinates
]]
]]
local function parseDec( lat, long, format )
function convert_dec2dms(coordinate, firstPostfix, secondPostfix, precision)
local coordinateSpec = {}
    local coord = tonumber(coordinate) or 0
local errors = {}
    local postfix
    if coord >= 0 then
        postfix = firstPostfix
    else
        postfix = secondPostfix
    end


if not long then
    precision = precision:lower();
return nil, {{"parseDec", "Missing longitude"}}
    if precision == "dms" then
elseif not tonumber(long) then
        return convert_dec2dms_dms( math.abs( coord ) ) .. postfix;
return nil, {{"parseDec", "Longitude could not be parsed as a number: " .. long}}
    elseif precision == "dm" then
end
        return convert_dec2dms_dm( math.abs( coord ) ) .. postfix;
    elseif precision == "d" then
        return convert_dec2dms_d( math.abs( coord ) ) .. postfix;
    end
end


errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );
--[[ Helper function, convert decimal to degrees ]]
coordinateSpec["dec-lat"]  = lat;
function convert_dec2dms_d(coordinate)
coordinateSpec["dec-long"] = long;
    local d = math_mod._round( coordinate, 0 ) .. "°"
    return d .. ""
end


local mode = coordinates.determineMode( lat, long );
--[[ Helper function, convert decimal to degrees and minutes ]]
coordinateSpec["dms-lat"]  = convert_dec2dms( lat, "N", "S", mode)  -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
function convert_dec2dms_dm(coordinate)
coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode) -- {{coord/dec2dms|{{{2}}}|E|W|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
    coordinate = math_mod._round( coordinate * 60, 0 );
 
    local m = coordinate % 60;
if format then
    coordinate = math.floor( (coordinate - m) / 60 );
coordinateSpec.default = format
    local d = coordinate % 360 .."°"
else
coordinateSpec.default = "dec"
end


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


--[[
--[[ Helper function, convert decimal to degrees, minutes, and seconds ]]
parseDMS
function convert_dec2dms_dms(coordinate)
 
    coordinate = math_mod._round( coordinate * 60 * 60, 0 );
Transforms degrees, minutes, seconds format latitude and longitude
    local s = coordinate % 60
into the a structure to be used in displaying coordinates
    coordinate = math.floor( (coordinate - s) / 60 );
]]
    local m = coordinate % 60
local function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )
    coordinate = math.floor( (coordinate - m) / 60 );
local coordinateSpec, errors, backward = {}, {}
    local d = coordinate % 360 .."°"
 
lat_f = lat_f:upper();
long_f = long_f:upper();
 
-- Check if specified backward
if lat_f == 'E' or lat_f == 'W' then
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;
end
 
errors = validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, 'parseDMS', true );
if not long_d then
return nil, {{"parseDMS", "Missing longitude" }}
elseif not tonumber(long_d) then
return nil, {{"parseDMS", "Longitude could not be parsed as a number:" .. long_d }}
end
 
if not lat_m and not lat_s and not long_m and not long_s 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, backward
    return d .. string.format( "%02d′", m ) .. string.format( "%02d″", s )
end
end


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


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


if not args[1] then
    local precision = 0
-- no lat logic
    if seconds_str ~= nil and seconds_str ~= '' then
return errorPrinter( {{"formatTest", "Missing latitude"}} )
        precision = 5 + math.max( math_mod._precision(seconds_str), 0 );
elseif not tonumber(args[1]) then
    elseif minutes_str ~= nil and minutes_str ~= '' then
-- bad lat logic
        precision = 3 + math.max( math_mod._precision(minutes_str), 0 );
return errorPrinter( {{"formatTest", "Unable to parse latitude as a number:" .. args[1]}} )
    else
elseif not args[4] and not args[5] and not args[6] then
        precision = math.max( math_mod._precision(degrees_str), 0 );
-- dec logic
    end
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 extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
    local decimal = factor * (degrees+(minutes+seconds/60)/60)
for _, v in ipairs(extra_param) do
    return string.format( "%." .. precision .. "f", decimal ) -- not tonumber since this whole thing is string based.
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


--[[
--[[
Generate Wikidata tracking categories.
Checks input values to for out of range errors.
]]
]]
local function makeWikidataCategories(qid)
function validate( lat_d, lat_m, lat_s, long_d, long_m, long_s, source, strong )
local ret
    local errors = {};
if mw.wikibase and current_page.namespace == 0 then
    lat_d = tonumber( lat_d ) or 0;
local entity = qid and mw.wikibase.getEntityObject(qid) or mw.wikibase.getEntityObject()
    lat_m = tonumber( lat_m ) or 0;
if entity and entity.claims and entity.claims.P625 and entity.claims.P625[1] then
    lat_s = tonumber( lat_s ) or 0;
local snaktype = entity.claims.P625[1].mainsnak.snaktype
    long_d = tonumber( long_d ) or 0;
if snaktype == 'value' then
    long_m = tonumber( long_m ) or 0;
-- coordinates exist both here and on Wikidata, and can be compared.
    long_s = tonumber( long_s ) or 0;
ret = 'Coordinates on Wikidata'
 
elseif snaktype == 'somevalue' then
    if strong then
ret = 'Coordinates on Wikidata set to unknown value'
        if lat_d < 0 then
elseif snaktype == 'novalue' then
            table.insert(errors, {source, "latitude degrees < 0 with hemisphere flag"})
ret = 'Coordinates on Wikidata set to no value'
        end
end
        if long_d < 0 then
else
            table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
-- We have to either import the coordinates to Wikidata or remove them here.
        end
ret = 'Coordinates not on Wikidata'
        --[[
end
        #coordinates is inconsistent about whether this is an error.  If globe: is
end
        specified, it won't error on this condition, but otherwise it will.
if ret then
return string.format('[[Category:%s]]', ret)
else
return ''
end
end


--[[
        For not simply disable this check.
link


Simple function to export the coordinates link for other uses.
        if long_d > 180 then
            table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
        end
        ]]
    end


Usage:
    if lat_d > 90 then
{{#invoke:Coordinates | link }}
        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;
function coordinates.link(frame)
return coord_link;
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.
]]
]]
coordinates.dec2dms = makeInvokeFunc('_dec2dms')
function coordinates.dec2dms(frame)
function coordinates._dec2dms(args)
    globalFrame = frame
local coordinate = args[1]
    local coordinate = numeral_converter.convert( "en", frame.args[1] )
local firstPostfix = args[2] or ''
    local firstPostfix = numeral_converter.convert( "en", frame.args[2] )
local secondPostfix = args[3] or ''
    local secondPostfix = numeral_converter.convert( "en", frame.args[3] )
local precision = args[4] or ''
    local precision = numeral_converter.convert( "en", frame.args[4] )


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).
]]
]]
coordinates.dms2dec = makeInvokeFunc('_dms2dec')
function coordinates.dms2dec(frame)
function coordinates._dms2dec(args)
    globalFrame = frame
local direction = args[1]
    local direction = numeral_converter.convert( "en", frame.args[1] )
local degrees = args[2]
    local degrees = numeral_converter.convert( "en", frame.args[2] )
local minutes = args[3]
    local minutes = numeral_converter.convert( "en", frame.args[3] )
local seconds = args[4]
    local seconds = numeral_converter.convert( "en", frame.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}}.
]]
]]
coordinates.coord = makeInvokeFunc('_coord')
function coordinates.coord(frame)
function coordinates._coord(args)
    globalFrame = frame
if not tonumber(args[1]) and not args[2] then
    local args = frame.args
args[3] = args[1]; args[1] = nil
    if args[1] == nil then
local entity = mw.wikibase.getEntityObject(args.qid)
        local pFrame = frame:getParent();
if entity
        args = pFrame.args;
and entity.claims
        for k,v in pairs( frame.args ) do
and entity.claims.P625
            args[k] = numeral_converter.convert( "en", v );
and entity.claims.P625[1].mainsnak.snaktype == 'value'
        end
then
    end
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


local text = ''
    for i=1,10 do
if isInline(Display) then
        if args[i] == nil then
text = text .. displayinline(contents, Notes)
            args[i] = ""
end
        else
if isInTitle(Display) then
            args[i] = numeral_converter.convert( "en", args[i]:match( '^%s*(.-)%s*$' ) );
text = text
              -- converting to English and remove whitespaces
.. displaytitle(contents, Notes)
        end
.. makeWikidataCategories(args.qid)
    end
end
    args['format'] = args['format'] or '';
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)
coord2text
    local Notes = args.notes or ""
    local Display = string.lower(args.display or "inline")
    if Display == '' then
        Display = 'inline';
    end


Extracts a single value from a transclusion of {{Coord}}.
     local text = ''
IF THE GEOHACK LINK SYNTAX CHANGES THIS FUNCTION MUST BE MODIFIED.
    if string.find( Display, 'inline' ) ~= nil or Display == 'i' or
 
            Display == 'it' or Display == 'ti' then
Usage:
        text = displayinline(contents, Notes)
 
    end
     {{#invoke:Coordinates | coord2text | {{Coord}} | parameter }}
     if string.find( Display, 'title' ) ~= nil or Display == 't' or
 
            Display == 'it' or Display == 'ti' then
Valid values for the second parameter are: lat (signed integer), long (signed integer), type, scale, dim, region, globe, source
        text = text .. displaytitle(contents, Notes)
 
    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
لطفاً توجه داشته‌باشید که همهٔ مشارکت‌ها در ویکی حج منتشرشده تحت Creative Commons Attribution-NonCommercial-ShareAlike در نظر گرفته‌می‌شوند (برای جزئیات بیش‌تر ویکی حج:حق تکثیر را ببینید). اگر نمی‌خواهید نوشته‌هایتان بی‌رحمانه ویرایش و توزیع شوند؛ بنابراین، آنها را اینجا ارائه نکنید.
شما همچنین به ما تعهد می‌کنید که خودتان این را نوشته‌اید یا آن را از یک منبع با مالکیت عمومی یا مشابه آزاد آن برداشته‌اید (برای جزئیات بیش‌تر ویکی حج:حق تکثیر را ببینید). کارهای دارای حق تکثیر را بدون اجازه ارائه نکنید!
لغو راهنمای ویرایش‌کردن (در پنجرهٔ تازه باز می‌شود)

الگوی به‌کاررفته در این صفحه: