Modul:Coordinates

--[[ Denna modul är importerad från http://en.wikipedia.org/w/index.php?title=Module:Coordinates&oldid=549737389 Se denna sidas historik för bidragsgivare

This module is intended to replace the functionality of
and related templates. It provides several methods, including

 : General function formatting and displaying coordinate values.

 : Simple function for converting decimal degree values to DMS format.

 : Simple function for converting DMS format to decimal degree format.

]]

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

coordinates = {};

--[[

 wd_coord, hämtar geografisk koordinat (property P625) från wikidata för sidan med funktionsanropet och returnerar resultatet av anrop till functionen Coordinates:coord
 om funktionen anropas från en sida som saknar geografisk koordinat i wikidata så returneras parametrar motsvarande latitud 0 och longitud 0.
 latitud och longitud avrundas i enlighet med värdet på precision (som är en del av P625).

 parametrar
 ==========
 display: display som coord vill ha den, inline eller title eller inline,title. default är 'title'
 region: regionkod som coord vill ha den. default är 'SE'
 type : type som coord vill ha den. default är 'adm1state'

]]

function startsWith(str, substr) return str:sub(1, #substr) == substr end

function coordinates.wd_coord(frame)

local res = local lat = 0 local latd = 0 local latm = 0 local lats = 0 local latNS = 'N' local long = 0 local longd = 0 local longm = 0 local longs = 0 local longEW = 'E' local prec = 0 local disp = frame.args['display'] or 'title' local type = frame.args['type'] or 'adm1st' local reg = frame.args['region'] or 'SE' local table entity = mw.wikibase.getEntityObject()

if entity == nil then return else

		if entity.claims.P625 == nil then

return else if entity.claims.P625[1].mainsnak.snaktype ~= 'value' then if entity.claims.P625[1].mainsnak.snaktype ~= 'novalue' then return end if entity.claims.P625[1].mainsnak.snaktype ~= 'somevalue' then return end else prec = tonumber(entity.claims.P625[1].mainsnak.datavalue.value.precision) if (prec == nil) then prec = 1/3600 end lat = tonumber(entity.claims.P625[1].mainsnak.datavalue.value.latitude) if lat < 0 then latNS = 'S' end lat = math.abs(lat) lat = math.floor(lat/prec + 1/2) * prec long = tonumber(entity.claims.P625[1].mainsnak.datavalue.value.longitude) if long < 0 then longEW = 'W' end long = math.abs(long) long = math.floor(long/prec + 1/2) * prec latd = math.floor(lat) lat = (lat - latd) * 60 latm = math.floor(lat) lats = (lat - latm) * 60 if (prec >= 1/3600.001) then lats = math.floor(lats + 1/2) end if (lats >= 60) then lats = lats - 60 latm = latm + 1 end if (latm == 60) then latm = 0 latd = latd + 1 end

longd = math.floor(long) long = (long - longd) * 60 longm = math.floor(long) longs = (long - longm) * 60 if (prec >= 1/3600.001) then longs = math.floor(longs + 1/2) end if (longs >= 60) then longs = longs - 60 longm = longm + 1 end if (longm == 60) then longm = 0 longd = longd + 1 end

local antal_decimaler = 3 if (prec >= 1e-8) then antal_decimaler = math.max(0,math.floor(-math.log(prec*3600)/math.log(10)+0.5)) end

local format = coordinates.wdprec2dms(frame) if (format == 'd') then frame.args = {latd .. "", latNS, longd .. "", longEW, display=disp, 'region:'..reg..'_type:'..type..'_source:Wikidata'} end if (format == 'dm') then frame.args = {latd .. "", latm .. "", latNS, longd .. "", longm .. "", longEW, display=disp, 'region:'..reg..'_type:'..type..'_source:Wikidata'} end if (format == 'dms') then frame.args = {latd .. "", latm .. "", string.format('%2.'..antal_decimaler..'f',lats) .. "",latNS, longd .. "", longm .. "",string.format('%2.'..antal_decimaler..'f',longs) .. "",longEW, display=disp, 'region:'..reg..'_type:'..type..'_source:Wikidata'} end return coordinates.coord(frame) end end end end

-- wdprec2dms, översätter från värdet precision för geografisk koordinat (property P625) till format dms som kan användas vid anrop av Coordinates.coord -- om precision är 1/3600 (eller mindre) blir format = dms -- om precision är mellan 1/3600 och 1/60 blir format = dm -- om precision är större än 1/60 blir format = d

function coordinates.wdprec2dms(frame) local prec = 0 entity = mw.wikibase.getEntityObject() if entity then

     prec = tonumber(entity.claims.P625[1].mainsnak.datavalue.value.precision)
     if (prec == nil) then prec = 1/3600 end
   end 
   res = 'd'
   if (prec <= 1/59.99) then res = 'dm' end
   if (prec <= 1/3599.99) then res = 'dms' end
   return res
end

--[[ Helper function, replacement for ]] function displaytitle (s, notes, globe) local l = "Koordinater: " .. s local co = ''; return globalFrame:preprocess( '' ); end

--[[ Helper function, Replacement for {{{1}}} ]] 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, Mall:"parseDec", "Missing longitude"
   end
   
   errors = validate( lat, nil, nil, long, nil, nil, 'parseDec', false );    
   coordinateSpec["dec-lat"]  = lat;
   coordinateSpec["dec-long"] = long;

   local mode = coordinates.determineMode( lat, long );
   coordinateSpec["dms-lat"]  = convert_dec2dms( lat, "N", "S", mode)  -- °′″
   coordinateSpec["dms-long"] = convert_dec2dms( long, "E", "W", mode)  -- °′″    
   
   if format ~= "" then
       coordinateSpec.default = format
   else
       coordinateSpec.default = "dec"
   end

   return coordinateSpec, errors

end

--Helper function, handle optional args. function optionalArg(arg, suplement)

   if arg ~= nil and arg ~= "" then
       return arg .. suplement
   end
   return ""

end

--[[ parseDMS

Transforms degrees, minutes, seconds format latitude and longitude into the a structure to be used in displaying coordinates ]] function parseDMS( lat_d, lat_m, lat_s, lat_f, long_d, long_m, long_s, long_f, format )

   local coordinateSpec = {}
   local errors = {}
   
   lat_f = lat_f:upper();
   long_f = long_f:upper();
   
   if long_f == 'W' then
       long_f = 'V';    
   end
   if long_f == 'E' then
       long_f = 'Ö';    
   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", "Missing longitude" })
   end
   
   if lat_m == nil and lat_s == nil and long_m == nil and long_s == nil and #errors == 0 then 
       if math_mod._precision( lat_d ) > 0 or math_mod._precision( long_d ) > 0 then
           if lat_f:upper() == 'S' then 
               lat_d = '-' .. lat_d;
           end
           if long_f:upper() == 'V' 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) -- 
   coordinateSpec["dec-long"] = convert_dms2dec(long_f, long_d, long_m, long_s) -- 

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

   return coordinateSpec, errors

end

--[[ specPrinter

Output formatter. Takes the structure generated by either parseDec or parseDMS and formats it for inclusion on Wikipedia. ]] function specPrinter(args, coordinateSpec)

   local uriComponents = coordinateSpec["param"]
   if uriComponents == "" then
       -- RETURN error, should never be empty or nil
       return "ERROR param was empty"
   end
   if args["name"] ~= "" and args["name"] ~= nil then
       uriComponents = uriComponents .. "&title=" .. mw.uri.encode(coordinateSpec["name"])
   end
   
   local geodmshtml = ''
            .. '' .. coordinateSpec["dms-lat"] .. ' '
            .. '' ..coordinateSpec["dms-long"] .. ''
            .. ''

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

   local long = tonumber( coordinateSpec["dec-long"] ) or 0
   if long < 0 then
       -- FIXME does not handle unicode minus
       geodeclong = coordinateSpec["dec-long"]:sub(2) .. "°V"
   else
       geodeclong = (coordinateSpec["dec-long"] or 0) .. "°Ö"
   end
   
   local geodechtml = ''
            .. geodeclat .. ' '
            .. geodeclong
            .. ''

   local geonumhtml = ''
            .. coordinateSpec["dec-lat"] .. '; '
            .. coordinateSpec["dec-long"]
            .. ''

   local inner;
   inner = '' .. geodmshtml .. ''
               .. ''
               .. '';

   if args["name"] == "" or args["name"] == nil then
       inner = inner .. geodechtml 
               .. ' / ' .. geonumhtml .. ''
   else
       inner = inner .. '' .. geodechtml 
               .. ' / ' .. geonumhtml .. ''
               .. ' ('
               .. args["name"] .. ')'
   end

   return '' .. globalFrame:preprocess(
       '[//tools.wmflabs.org/geohack/geohack.php?language=sv&pagename=Modul:Coordinates&params=' ..
       uriComponents .. ' ' .. inner .. ']') .. ''

end

--[[ Formats any error messages generated for display ]] function errorPrinter(errors)

   local result = ""
   for i,v in ipairs(errors) do
       local errorHTML = ''
       result = result .. errorHTML .. "
"
   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
template mode is the display mode (dec or dms) that we will need to determine the css class for ]] function displayDefault(default, mode)

   if default == "" then
       default = "dec"
   end
   
   if default == mode then
       return "geo-default"
   else
       return "geo-nondefault"
   end

end

--[[ Check the input arguments for coord to determine the kind of data being provided and then make the necessary processing. ]] function formatTest(args)

   local result, errors;
   local primary = false;
   
   if args[1] == "" then
       -- no lat logic
       return errorPrinter( Mall:"formatTest", "Latitud saknas" )
   elseif args[4] == "" and args[5] == "" and args[6] == "" then
       -- dec logic
       result, errors = parseDec( args[1], args[2], args['format'] )
       if result == nil then
           return errorPrinter( errors );
       end              
       result.param    = table.concat( {args[1], "_N_", args[2], "_E_", args[3] } );
   elseif dmsTest(args[4], args[8]) then
       -- dms logic
       result, errors = parseDMS( args[1], args[2], args[3], args[4], 
           args[5], args[6], args[7], args[8], args['format'] )
       result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
           args[6], args[7], args[8], args[9] } , '_' );
       if args[10] ~=  then
           table.insert( errors, { 'formatTest', 'Extra okända parametrar' } );
       end        
   elseif dmsTest(args[3], args[6]) then
       -- dm logic
       result, errors = parseDMS( args[1], args[2], nil, args[3], 
           args[4], args[5], nil, args[6], args['format'] )
       result.param = table.concat( { args[1], args[2], args[3], args[4], args[5],
           args[6], args[7] } , '_' );
       if args[8] ~=  then
           table.insert( errors, { 'formatTest', 'Extra okända parametrar' } );
       end        
   elseif dmsTest(args[2], args[4]) then
       -- d logic
       result, errors = parseDMS( args[1], nil, nil, args[2], 
           args[3], nil, nil, args[4], args['format'] )
       result.param = table.concat( { args[1], args[2], args[3], args[4], args[5] } , '_' );
       if args[6] ~=  then
           table.insert( errors, { 'formatTest', 'Extra okända parametrar' } );
       end        
   else
       -- Error
       return errorPrinter( Mall:"formatTest", "Unknown argument format" )
   end
   result.name     = args["name"]
   
   local extra_param = {'dim', 'globe', 'scale', 'region', 'source', 'type'}
   for _, v in ipairs( extra_param ) do
       if (args[v] or ) ~=  then 
           table.insert( errors, {'formatTest', 'Parameter: "' .. v .. '=" bör vara "' .. v .. ':"' } );
       end
   end
   
   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
   if direction == "N" or direction == "E" or direction == "Ö" 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, "latitude degrees < 0 with hemisphere flag"})
       end
       if long_d < 0 then
           table.insert(errors, {source, "longitude degrees < 0 with hemisphere flag"})
       end
       --[[ 
       #coordinates is inconsistent about whether this is an error.  If globe: is
       specified, it won't error on this condition, but otherwise it will.
       
       For not simply disable this check.
       
       if long_d > 180 then
           table.insert(errors, {source, "longitude degrees > 180 with hemisphere flag"})
       end
       ]]
   end    
       
   if lat_d > 90 then
       table.insert(errors, {source, "latitude degrees > 90"})
   end
   if lat_d < -90 then
       table.insert(errors, {source, "latitude degrees < -90"})
   end
   if lat_m >= 60 then
       table.insert(errors, {source, "latitude minutes >= 60"})
   end
   if lat_m < 0 then
       table.insert(errors, {source, "latitude minutes < 0"})
   end
   if lat_s >= 60 then
       table.insert(errors, {source, "latitude seconds >= 60"})
   end
   if lat_s < 0 then
       table.insert(errors, {source, "latitude seconds < 0"})
   end
   if long_d >= 360 then
       table.insert(errors, {source, "longitude degrees >= 360"})
   end
   if long_d <= -360 then
       table.insert(errors, {source, "longitude degrees <= -360"})
   end
   if long_m >= 60 then
       table.insert(errors, {source, "longitude minutes >= 60"})
   end
   if long_m < 0 then
       table.insert(errors, {source, "longitude minutes < 0"})
   end
   if long_s >= 60 then
       table.insert(errors, {source, "longitude seconds >= 60"})
   end
   if long_s < 0 then
       table.insert(errors, {source, "longitude seconds < 0"})
   end
   
   return errors;

end

--[[ dec2dms

Wrapper to allow templates to call dec2dms directly.

Usage:

   Mall:Invoke:Coordinates
   

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:

   Mall:Invoke:Coordinates
   

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

Usage:

   Mall:Invoke:Coordinates
   Mall:Invoke:Coordinates
   Mall:Invoke:Coordinates
   ...
   
   Refer to 
 documentation page for many additional parameters and 
   configuration options.
   

Note: This function provides the visual display elements of
. In order to load coordinates into the database, the parser function must also be called, this is done automatically in the Lua version of
. ]] 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 globe = for k, v in pairs(args) do if startsWith(v, 'globe:') then globe = v end end globe = globe:gsub('globe:', )

   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, globe)
   end
   return text

end

return coordinates