ФЭНДОМ


--[[
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.
 
]]
 
math_mod = require( "Module:Math" );
globalFrame = nil
 
coordinates = {};
 
--[[ Helper function, replacement for {{coord/display/title}} ]]
function displaytitle (s, notes, globalFrame)
    return globalFrame:extensionTag{
    	name = 'indicator',
    	content = s .. notes,
    	args = { name = '0-coord' }
	};
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", "Пропущена долгота"}}
    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, " с. ш.", " ю. ш.", mode)  -- {{coord/dec2dms|{{{1}}}|N|S|{{coord/prec dec|{{{1}}}|{{{2}}}}}}}
    coordinateSpec["dms-long"] = convert_dec2dms( long, " в. д.", " з. д.", 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 string.format( "%02d", tonumber( 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", "Пропущена долгота" })
    end
 
    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 lat_m == nil and lat_s == nil and long_m == nil and long_s == nil and #errors == 0 
        or math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
            if lat_f:upper() == 'S' then
                lat_d = '-' .. lat_d;
                lat_f = " ю. ш.";
            else
                lat_f = " с. ш.";
            end
            if long_f:upper() == 'W' then
                long_d = '-' .. long_d;
                long_f = " з. д.";
            else
                long_f = " в. д.";
            end
 
            return parseDec( lat_d, long_d, format );
    end
 
    if lat_f:upper() == 'S' then
        lat_f = " ю. ш.";
    else
        lat_f = " с. ш.";
    end
 
    if long_f:upper() == 'E' then
        long_f = " в. д.";
    else
        long_f = " з. д.";
    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
 
    if format ~= "" then
        coordinateSpec.default = format
    else
        coordinateSpec.default = "dms"
    end
 
    return coordinateSpec, errors
end
 
--[[
splitParam
 
Split the parameter string and convert it into an object.
]]
function splitParam( param )
	local out = {}
	for pair in mw.text.gsplit( param, '_', true ) do
		local keyValue = mw.text.split( pair, ':', true )
		if #keyValue == 2 then
			out[keyValue[1]] = keyValue[2]
		end
	end
	return out
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 "Ошибка: не задан param"
    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="Различные карты и схемы для этого места">'
             .. '<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) .. "°&nbsp;ю.&nbsp;ш."
    else
        geodeclat = (coordinateSpec["dec-lat"] or 0) .. "°&nbsp;с.&nbsp;ш."
    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) .. "°&nbsp;з.&nbsp;д."
    else
        geodeclong = (coordinateSpec["dec-long"] or 0) .. "°&nbsp;в.&nbsp;д."
    end
 
    local geodechtml = '<span class="geo-dec" title="Различные карты и схемы для этого места">'
             .. geodeclat .. ' '
             .. geodeclong
             .. '</span>'
 
    local geonumhtml = '<span class="geo">'
             .. coordinateSpec["dec-lat"] .. '; '
             .. coordinateSpec["dec-long"]
             .. '</span>'
 
    local inner;
    inner = '<span class="geo-geo-' .. coordinateSpec.default .. '"><span class="geo-dms">' .. geodmshtml .. '</span>'
                .. '<span class="geo-multi-punct">&#xfeff; / &#xfeff;</span>'
                .. '<span class="geo-dec">';
 
    if args["name"] == "" or args["name"] == nil then
        inner = inner .. geodechtml
                .. '<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></span>'
    end
 
	local params = splitParam( coordinateSpec.param )
	local type = string.gsub( string.lower( params.type or '' ), '%(.+$', '' )
 
	local scale
	if args.scale and args.scale ~= '' then
		scale = tonumber( args.scale )
	end
	if not scale then
		local typeScale = {
			adm1st = 1000000,
			adm2nd = 300000,
			adm3rd = 100000,
			airport = 30000,
			city = 100000,
			country = 10000000,
			edu = 10000,
			event = 50000,
			forest = 50000,
			glacier = 50000,
			isle = 100000,
			landmark = 10000,
			mountain = 100000,
			pass = 10000,
			railwaystation = 10000,
			river = 100000,
			satellite = 10000000,
			waterbody = 100000,
			camera = 10000
		}
		if typeScale[type] then
			scale = typeScale[type]
		else
			scale = 30000
		end
	end
 
	if scale < 2000 then zoom = 18
	elseif scale <   5000 then zoom = 17
	elseif scale <  10000 then zoom = 16
	elseif scale <  20000 then zoom = 15
	elseif scale <  40000 then zoom = 14
	elseif scale <  80000 then zoom = 13
	elseif scale < 160000 then zoom = 12
	elseif scale < 320000 then zoom = 11
	elseif scale < 640000 then zoom = 10
	elseif scale < 1280000 then zoom = 9
	elseif scale < 2560000 then zoom = 8
	elseif scale < 5120000 then zoom = 7
	elseif scale < 10240000 then zoom = 6
	elseif scale < 20480000 then zoom = 5
	elseif scale < 40960000 then zoom = 4
	else zoom = 3
	end
 
	local maplinkArgs = {
		['latitude'] = coordinateSpec['dec-lat'],
		['longitude'] = coordinateSpec['dec-long'],
		['zoom'] = zoom,
		['text'] = coordinateSpec["dms-lat"] .. ' ' .. coordinateSpec["dms-long"],
		['title'] = mw.title.getCurrentTitle().text
	}
 
	-- if args['name'] and args['name'] ~= '' then
	-- 	maplinkArgs['text'] = args['name']
	-- end
	if args['title'] and args['title'] ~= '' then
		maplinkArgs['title'] = args['title']
	end
 
	local maplinkMarkerSymbol = 'star'
	local markerSymbols = {
		adm1st = 'city',
		adm2nd = 'city',
		adm3rd = 'city',
		airport = 'airport',
		city = 'city',
		country = 'city',
		edu = 'college',
		forest = 'park-alt',
		glacier = 'mountain',
		mountain = 'mountain',
		pass = 'mountain',
		railwaystation = 'rail',
		river = 'water',
		satellite = 'rocket',
		waterbody = 'water',
		camera = 'attraction'
	}
	if markerSymbols[type] then
		maplinkMarkerSymbol = markerSymbols[type]
	end
 
	local maplinkContent = [[ {
		"type": "Feature",
		"geometry": {
			"type": "Point",
			"coordinates": [
				]] .. coordinateSpec['dec-long'] .. [[,
				]] .. coordinateSpec['dec-lat'] .. [[
			]
		},
		"properties": {
			"title": "]] .. mw.text.encode( maplinkArgs['title'] ) .. [[",
			"marker-symbol": "]] .. maplinkMarkerSymbol .. [[",
			"marker-color": "#3366cc"
		}
    } ]];
 
    local entityId = mw.wikibase.getEntityIdForCurrentPage()
    if entityId then
	    maplinkContent = maplinkContent .. [[, {
			"type": "ExternalData",
			"service": "geoline",
			"ids": "]] .. mw.wikibase.getEntityIdForCurrentPage() .. [[",
			"properties": {
				"stroke": "#FF9999"
			}
	    }, {
			"type": "ExternalData",
			"service": "geoshape",
			"ids": "]] .. mw.wikibase.getEntityIdForCurrentPage() .. [[",
			"properties": {
				"fill": "#FF0000",
				"fill-opacity": 0.1,
				"stroke": "#FF9999"
			}
	    } ]]
    end
 
    local globe = string.lower( args.globe or params.globe or '' )
 
	local result = '<span class="coordinates plainlinks nourlexpansion" data-param="' .. mw.text.encode( coordinateSpec.param ) .. '">'
	if globe == '' or globe == 'earth' then
	    result = result .. '<span title="Показать карту">' .. globalFrame:extensionTag{
	    	name = 'maplink',
	    	content = '[' .. maplinkContent .. ']',
	    	args = maplinkArgs
    	} .. '</span>'
	else
		-- FIXME [[phab:T151138]]
	    result = result .. globalFrame:preprocess(
	        '[//tools.wmflabs.org/geohack/geohack.php?language=ru&pagename={{FULLPAGENAMEE}}&params=' ..
	        uriComponents .. ' ' .. inner .. ']' )
    end
 
	-- external links
	local nogoogle = string.lower( args.nogoogle or '' )
	local noosm = string.lower( args.noosm or '' )
	local noyandex = string.lower( args.noyandex or '' )
 
    if globe == '' then
        if nogoogle == '' or noosm == '' or noyandex == '' then
	        result = result .. '<sup class="geo-services noprint">'
 
	        result = result .. globalFrame:preprocess(
	        '<span class="geo-geohack" title="Карты и инструменты на GeoHack">' ..
	        '[//tools.wmflabs.org/geohack/geohack.php?language=ru&pagename={{FULLPAGENAMEE}}&params=' ..
	        uriComponents .. ' ' .. '<span>H</span>]</span>' )
 
	        if nogoogle == '' then
	            result = result .. '<span class="geo-google" title="Это место на «Картах Google»">[//maps.google.com/maps?'
	                .. 'll=' ..  coordinateSpec["dec-lat"] .. ',' .. coordinateSpec["dec-long"]
	                .. '&q=' ..  coordinateSpec["dec-lat"] .. ',' .. coordinateSpec["dec-long"]
	                .. '&spn=' .. (scale / 1000000) .. ',' .. (scale / 1000000)
	                .. '&t=h&hl=ru '
	                .. '<span>G</span>]</span>'
	        end
	        if noyandex == '' then
	            result = result .. '<span class="geo-yandex" title="Это место на «Яндекс.Картах»">[//yandex.ru/maps/'
	                .. '?ll=' .. coordinateSpec["dec-long"] .. ',' .. coordinateSpec["dec-lat"]
	                .. '&pt=' .. coordinateSpec["dec-long"] .. ',' .. coordinateSpec["dec-lat"]
	                .. '&spn=' .. (scale / 1000000) .. ',' .. (scale / 1000000)
	                .. '&l=' .. 'sat,skl '
	                .. '<span>Я</span>]</span>'
	        end
	        if noosm == '' then
	            result = result .. '<span class="geo-osm" title="Это место на карте OpenStreetMap">[https://www.openstreetmap.org/?'
	                .. 'mlat=' .. coordinateSpec["dec-lat"] .. '&mlon=' .. coordinateSpec["dec-long"]
	                .. '&zoom=' .. zoom .. ' '
	                .. '<span>O</span>]</span>'
	        end
	        result = result .. '</sup>'
	    end
    end
 
    result = result .. '</span>'
 
    return result
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">Координаты: ' .. 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;
 
    local param = {}
 
    if args[1] == "" then
        -- no lat logic
        return errorPrinter( {{"formatTest", "Пропущена широта"}} )
    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
        param = { 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'] )
        param = { 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'] )
        param = { 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'] )
        param = { 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 last = table.getn (param)
    if param[last] == '' then
        table.remove(param, last)
    end
 
    local extra_param = { 'dim', 'globe', 'scale', 'region', 'source', 'type' }
    for _, v in ipairs( extra_param ) do
        if (args[v] or '') ~= '' then
            table.insert( param, v .. ':' .. args[v] );
        end
    end
 
    result.param = table.concat( param , '_' );
 
    if #errors == 0 then
        return specPrinter( args, result )
    else
        return specPrinter( args, result ) .. " " .. errorPrinter(errors) .. '[[Категория:Википедия:Статьи с ошибочными параметрами координат]]';
    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
    direction = mw.ustring.gsub(direction, '^[ ]*(.-)[ ]*$', '%1');
    if direction == "S" or direction == "W" then
        factor = -1
    else
        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, "градусы широты  < 0"})
        end
        if long_d < 0 then
            table.insert(errors, {source, "градусы долготы < 0"})
        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, "градусы широты > 90"})
    end
    if lat_d < -90 then
        table.insert(errors, {source, "градусы широты < -90"})
    end
    if lat_m >= 60 then
        table.insert(errors, {source, "минуты широты >= 60"})
    end
    if lat_m < 0 then
        table.insert(errors, {source, "минуты широты < 0"})
    end
    if lat_s >= 60 then
        table.insert(errors, {source, "секунды широты >= 60"})
    end
    if lat_s < 0 then
        table.insert(errors, {source, "секунды широты < 0"})
    end
    if long_d >= 360 then
        table.insert(errors, {source, "градусы долготы >= 360"})
    end
    if long_d <= -360 then
        table.insert(errors, {source, "градусы долготы <= -360"})
    end
    if long_m >= 60 then
        table.insert(errors, {source, "минуты долготы >= 60"})
    end
    if long_m < 0 then
        table.insert(errors, {source, "минуты долготы < 0"})
    end
    if long_s >= 60 then
        table.insert(errors, {source, "секунды долготы >= 60"})
    end
    if long_s < 0 then
        table.insert(errors, {source, "секунды долготы < 0"})
    end
 
    return errors;
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 = ''
    if string.find( Display, 'inline' ) ~= nil or Display == 'i' or
            Display == 'it' or Display == 'ti' then
        text = displayinline(contents, Notes)
    end
    if string.find( Display, 'title' ) ~= nil or Display == 't' or
            Display == 'it' or Display == 'ti' then
        text = text .. displaytitle(contents, Notes, frame)
    end
    return text
end
 
return coordinates

Обнаружено использование расширения AdBlock.


Викия — это свободный ресурс, который существует и развивается за счёт рекламы. Для блокирующих рекламу пользователей мы предоставляем модифицированную версию сайта.

Викия не будет доступна для последующих модификаций. Если вы желаете продолжать работать со страницей, то, пожалуйста, отключите расширение для блокировки рекламы.