Modul: Harta de localizare IAU

 - [[
* Modul care implementează șablonul IAU Location Map.
]] -

require ( „Formular: fără globali” )

local getArgs = require ( 'Modul: Argumente' ). getArgs
local mRaDec = require ( 'Modul: RaDec' )
local cfg = mw . loadData ( „Modul: Harta de localizare / Configurare IAU” )
local errorCategory = '[[Categorie: Intrări de eroare ale modulului de localizare a hărții IAU]]'

- Handler de eroare pentru xpcall, formatați eroarea.
-
- @param {string} msg
- @return {șir}
funcție locală errhandler ( msg )
local cat = mw . titlu . getCurrentTitle (). spațiu de nume == 0 și errorCategory sau "
returnează string.format ( '<span class = "error">% s </span>% s' , msg , cat )
Sfârșit

- Returnează numărul rotunjit la numărul necesar de zecimale.
- http://lua-users.org/wiki/SimpleRound
-
- @param {number} num
- @param {number} idp
- @return {number}
runda funcției locale ( num , idp )
local mult = 10 ^ ( idp sau 0 )
returnează math.floor ( num * mult + 0,5 ) / mult
Sfârșit

- Convertiți declinația de la grade / minute / secunde la grade zecimale.
-
- @param {table} dec
- @return {number}
funcție locală dec2deg ( dec )
întoarce dec . semn * ( dec . d + dec . m / 60 + dec . s / 3600 )
Sfârșit

- Convertește ascensiunea dreaptă din ore / minute / secunde în grade zecimale.
-
- @param {table} ar
- @return {number}
funcție locală ar2deg ( ar )
întoarce ar . h * 15 + ar . m / 4 + ar . s / 240
Sfârșit

- Parsificați parametrul ar cu formatul „ore / minute / secunde”.
-
- @param {table} args
- @return {number}
funcție locală parseArSlash ( args )
local h , m , s = string.match ( args . ar , '^ ([% d] +) / (% d +) / ([% d,%.] +) $' )
h , m , s = tonumber ( h ), tonumber ( m ), tonumber ( s )
return ( h și m și s ) și ar2deg ({ h = h , m = m , s = s }) sau nul
Sfârșit

- Parsificați parametrul declinaz cu formatul „grade / minute / secunde”.
-
- @param {table} args
- @return {number}
funcție locală parseDecSlash ( args )
semn local
local d, m, s = String.match (args. declinaz, '^ (-?% d +) / (% d +) / ([% d,%.] +) $')
d , m , s = tonumber ( d ), tonumber ( m ), tonumber ( s )
dacă d atunci
semn = ( d < 0 sau tostring ( d ) == '-0' ) și - 1 sau 1
d = math.abs ( d )
Sfârșit
return ( semn și d și m și s ) și dec2deg ({ semn = semn , d = d , m = m , s = s }) sau zero
Sfârșit

- Returnează decalajul în pixeli de la marginea stângă a unui corp ceresc
- pe o anumită hartă, bazată pe ascensiune dreaptă, declinare,
- la lățimea dorită a hărții și a markerului.
- Funcțiile getX și getY au fost obținute din formulele Ysogo din
- Project_Discussions: Astronomy # Position_in_constellation_map:
- X = Ax + (Aw / 2) + (Ah / (DECsup-DECinf)) * (DECogg-DECfuoco) * sen ((ARmed-ARogg) / disang)
- Y = Ay + Ah- (Ah / (DECsup-DECinf)) * ((DECogg-DECfuoco) * cos ((ARmed-ARogg) / disang) - (DECinf-DECfuoco))
-
- hartă @param {table}
- @param {număr} ar
- @param {număr} dec
- @param {number} lățime
- @param {number} mărime
- @return {number}
funcția locală getX ( hartă , ar , dec , lățime , mărime )
local x = hartă . topor + harta . aw / 2 +
( hartă . ah / ( hartă . dec_sup - hartă . dec_inf )) *
( dec - hartă . fire_dec ) *
math.sin ((( map . ar_med - ar ) / map . dis_ang ) * ( math.pi / 180 ))
- scalați rezultatul după lățime și centrați markerul
întoarcere rotundă (x * lățime / hartă. iw - mărime mărime / 2)
Sfârșit

- Returnează decalajul în pixeli de la marginea superioară a unui corp ceresc
- pe o anumită hartă, bazată pe ascensiune dreaptă, declinare,
- la lățimea dorită a hărții și a markerului.
-
- hartă @param {table}
- @param {număr} ar
- @param {număr} dec
- @param {number} lățime
- @param {number} mărime
- @return {number}
funcția locală getY ( hartă , ar , dec , lățime , mărime )
y local = hartă . ay + hartă . ah -
( hartă . ah / ( hartă . dec_sup - hartă . dec_inf )) *
(( dec - map . fire_dec ) * math.cos ((( map . ar_med - ar ) / map . dis_ang ) * ( math.pi / 180 )) - ( map . dec_inf - map . fire_dec ) )
- scalați rezultatul după lățime și centrați markerul
return round (y * width / map. iw - marksize / 2)
Sfârșit

- Returnează un div pentru poziționarea hărții în corpul paginii
- în loc de într-un sinoptic.
-
- text @param {string}
- Imagine @param {string}
- @param {table} args
- @param {number} lățime
- @return {șir}
funcția locală getThumbnail ( text , imagine , argumente , lățime )
local divNode = mw . html . create ( 'div' )
divNode
: addClass ( 'thumb' )
: AddClass (. Args float == 'dreapta' și 'tright' sau 'tleft')
: etichetă ( „div” )
: addClass ( 'thumbinner' )
: css ( „lățime” , lățime .. „px” )
: wikitext ( text )
: etichetă ( „div” )
: addClass ( 'thumbcaption' )
: wikitext ( argumente . subtitrare sau '' )
: etichetă ( „div” )
: addClass ( ' mărire ' )
: wikitext ( string.format ( '[[: Fișier:% s]]' , imagine ))
returnare trimitere (divNode)
Sfârșit

- ================================================== ============================
- Funcții exportate
- ================================================== ============================

local p = {}

- Funcția de utilitate pentru manual, returnează lista codurilor de hartă configurate.
funcția p . hărți ()
local sortedMaps = {}
pentru cheie , _ în perechi ( cfg . hărți ) do
table.insert ( sortedMaps , cheie )
Sfârșit
table.sort ( sortedMaps )
întoarce-te mw . text . listToText ( sortedMaps )
Sfârșit

- Funcția de utilitate, returnează 1 dacă harta specificată este disponibilă altfel zero.
funcția p . hasmap ( cadru )
hartă locală = cadru . args [ 1 ] și mw . ustring . inferior ( cadru . args [ 1 ])
return ( cfg . alias [ hartă ] sau cfg . hărți [ hartă ]) și 1
Sfârșit

- Funcție pentru utilizare de către un alt modul.
funcția p . _principal ( argumente )
hartă locală , ar , dec , text
lățime locală = tonumber (args. lățime) sau 260
mărci locale = tonumber ( args . marksize ) sau 15
	
- obține harta
dacă arg . apoi harta
argumente . harta = mw . ustring . inferior (arg. harta)
altceva
eroare ( „hartă nespecificată” , 2 )
Sfârșit
- posibil alias
argumente . hartă = cfg . alias [ args . harta ] sau args . Hartă
dacă nu cfg . hărți [ args . hartă ] atunci
eroare ( „harta nu este disponibilă:” .. arg. harta, 2)
Sfârșit
hartă = cfg . hărți [ args . harta ]
	
- realizează ascensiunea dreaptă și declinarea
dacă arg . RA și arg . DEC atunci
ar = mRaDec . parseRA (args. RA)
dec = mRaDec . parseDEC (args. DEC)
dacă ar și dec atunci
ar = ar2deg ( ar )
dec = dec2deg ( dec )
Sfârșit
elseif arg . ar_dec și args . dec_dec atunci
ar = args . ar_dec
dec = args . dec_dec
elseif arg . ar și args . apoi declinare
ar = parseArSlash ( args )
dec = parseDecSlash ( args )
Sfârșit
dacă nu ar sau nu dec atunci
eroare ( „coordonate cerești nevalide” , 2 )
Sfârșit

- hartă dublă
dacă arg . hartă == 'ser' atunci
map = ar > 255 și map . cauda sau hartă . caput
Sfârșit
- pentru constelațiile care traversează meridianul fundamental
dacă hartă . ar_med > ar + 180 atunci
ar = ar + 360
Sfârșit

- utilizați șablonul Over Image
text = mw . getCurrentFrame (): expandTemplate {
title = „Peste imagine” ,
args = {
mai jos = hartă . imagine ,
sub_width = width .. 'px' ,
subtitrare = " ,
above = args . marca sau „Cercle rouge 100% .svg” ,
over_width = marksize .. 'px' ,
above_caption = args . nume sau '' ,
x = getX ( hartă , ar , dec , lățime , mărime )
y = getY ( hartă , ar , dec , lățime , mărime )
}
}

întoarce arg . sinoptic și text sau getThumbnail ( text , hartă . imagine , argumente , lățime + 2 )
Sfârșit

- Funcție pentru șablonul {{IAU Location Map}}.
funcția p . principal ( cadru )
return select ( 2 , xpcall ( funcție ()
retur p . _main ( getArgs ( cadru , { parentOnly = true }))
end , errhandler ))
Sfârșit

retur p