C # Lever/coucher de soleil avec latitude/longitude
Existe-t-il un moyen en C # de calculer une latitude et une longitude en fonction du moment où le soleil se lèvera et se lèvera pour un jour donné?
Calculs javascript ici. Maintenant, il vous suffit de mettre en communication.
Edit: les calculs sont dans le code source de cette page maintenant.
Edit: here est un lien direct vers le code source. Pas besoin d'aller à la chasse à travers le HTML.
J'ai utilisé NAA javascript et c # pour créer cette bibliothèque en C #.
Lever et coucher de soleil en C #
Je l'ai testé sur ces deux sites, et il affiche l'heure exactement comme le font les sites.
Cette API semble fonctionner pour moi:
Je sais que ce post est vieux, mais au cas où quelqu'un cherche encore ...
CoordinateSharp est disponible sous forme de package Nuget. C'est un pack autonome qui peut gérer le soleil et les heures de la lune.
Celestial cel = Celestial.CalculateCelestialTimes(85.57682, -70.75678, new DateTime(2017,8,21));
Console.WriteLine(cel.SunRise.Value.ToString());
Remarque:
Cela suppose que les heures sont toujours en UTC.
Enfin, vous devrez peut-être référencer les objets célestes Soleil/Lune .Condition si une date renvoie null. Cela se produit lorsque le soleil est levé/baissé toute la journée.
EDIT 1/9/2019
La bibliothèque a radicalement changé depuis ce poste. Il peut maintenant gérer les heures locales aussi bien.
La réponse acceptée était une implémentation de JavaScript, qui ne convenait pas à mon application car je devais effectuer le calcul en C #.
J'ai utilisé ce code C #: http://wiki.crowe.co.nz/Calculate%20Sunrise%2fSunset.ashx , que j'ai validé par rapport aux heures de lever/coucher de soleil ici: http: // www.timeanddate.com/astronomy/ .
Si j'arrondis les secondes à la minute près, les heures de lever et de coucher du soleil de l'implémentation C # correspondent aux valeurs correspondantes affichées sur timeanddate.com, y compris les cas de passage à l'heure d'été. Cependant, le code est un peu écrasant (à moins que vous n'aimiez les données de phase lunaire également), je vais donc le refactoriser afin de faire précisément ce que j'ai maintenant besoin, les chiffres sont corrects.
Version VB.Net de la réponse de dotsa, qui peut également déterminer automatiquement les fuseaux horaires.
Sortie (vérifiée en regardant le coucher de soleil ce soir):
Main.VB:
Module Main
Sub Main()
' http://www.timeanddate.com/Sun/usa/seattle
' http://www.esrl.noaa.gov/gmd/grad/solcalc/
' Vessy, Switzerland
Dim latitude As Double = 46.17062
Dim longitude As Double = 6.161667
Dim dst As Boolean = True
Dim timehere As DateTime = DateTime.Now
Console.WriteLine("It is currently {0:HH:mm:ss} UTC", DateTime.UtcNow)
Console.WriteLine("The time here, at {0}°,{1}° is {2:HH:mm:ss}", latitude, longitude, timehere)
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim zone As Integer = local.BaseUtcOffset().TotalHours
If local.SupportsDaylightSavingTime Then
Dim standard As String = local.StandardName
Dim daylight As String = local.DaylightName
dst = local.IsDaylightSavingTime(timehere)
Dim current As String = IIf(dst, daylight, standard)
Console.WriteLine("Daylight-saving time is supported here. Current offset {0:+0} hours, {1}", zone, current)
Else
Console.WriteLine("Daylight-saving time is not supported here")
End If
System.Console.WriteLine("Sunrise today {0}", Sunrises(latitude, longitude))
System.Console.WriteLine("Sunset today {0}", Sunsets(latitude, longitude))
System.Console.ReadLine()
End Sub
End Module
Sun.vb:
Public Module Sun
' Get sunrise time at latitude, longitude using local system timezone
Function Sunrises(latitude As Double, longitude As Double) As DateTime
Dim julian As Double = JulianDay(DateTime.Now)
Dim rises As Double = SunRiseUTC(julian, latitude, longitude)
Dim timehere As DateTime = DateTime.Now
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim dst As Boolean = local.IsDaylightSavingTime(timehere)
Dim zone As Integer = local.BaseUtcOffset().TotalHours
Dim result As DateTime = getDateTime(rises, zone, timehere, dst)
Return result
End Function
' Get sunset time at latitude, longitude using local system timezone
Function Sunsets(latitude As Double, longitude As Double) As DateTime
Dim julian As Double = JulianDay(DateTime.Now)
Dim rises As Double = SunSetUTC(julian, latitude, longitude)
Dim timehere As DateTime = DateTime.Now
Dim local As TimeZoneInfo = TimeZoneInfo.Local
Dim dst As Boolean = local.IsDaylightSavingTime(timehere)
Dim zone As Integer = local.BaseUtcOffset().TotalHours
Dim result As DateTime = getDateTime(rises, zone, timehere, dst)
Return result
End Function
' Convert radian angle to degrees
Public Function Degrees(angleRad As Double) As Double
Return (180.0 * angleRad / Math.PI)
End Function
' Convert degree angle to radians
Public Function Radians(angleDeg As Double) As Double
Return (Math.PI * angleDeg / 180.0)
End Function
'* Name: JulianDay
'* Type: Function
'* Purpose: Julian day from calendar day
'* Arguments:
'* year : 4 digit year
'* month: January = 1
'* day : 1 - 31
'* Return value:
'* The Julian day corresponding to the date
'* Note:
'* Number is returned for start of day. Fractional days should be
'* added later.
Public Function JulianDay(year As Integer, month As Integer, day As Integer) As Double
If month <= 2 Then
year -= 1
month += 12
End If
Dim A As Double = Math.Floor(year / 100.0)
Dim B As Double = 2 - A + Math.Floor(A / 4)
Dim julian As Double = Math.Floor(365.25 * (year + 4716)) + Math.Floor(30.6001 * (month + 1)) + day + B - 1524.5
Return julian
End Function
Public Function JulianDay([date] As DateTime) As Double
Return JulianDay([date].Year, [date].Month, [date].Day)
End Function
'***********************************************************************/
'* Name: JulianCenturies
'* Type: Function
'* Purpose: convert Julian Day to centuries since J2000.0.
'* Arguments:
'* julian : the Julian Day to convert
'* Return value:
'* the T value corresponding to the Julian Day
'***********************************************************************/
Public Function JulianCenturies(julian As Double) As Double
Dim T As Double = (julian - 2451545.0) / 36525.0
Return T
End Function
'***********************************************************************/
'* Name: JulianDayFromJulianCentury
'* Type: Function
'* Purpose: convert centuries since J2000.0 to Julian Day.
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* the Julian Day corresponding to the t value
'***********************************************************************/
Public Function JulianDayFromJulianCentury(t As Double) As Double
Dim julian As Double = t * 36525.0 + 2451545.0
Return julian
End Function
'***********************************************************************/
'* Name: calGeomMeanLongSun
'* Type: Function
'* Purpose: calculate the Geometric Mean Longitude of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* the Geometric Mean Longitude of the Sun in degrees
'***********************************************************************/
Public Function GemoetricMeanLongitude(t As Double) As Double
Dim L0 As Double = 280.46646 + t * (36000.76983 + 0.0003032 * t)
While L0 > 360.0
L0 -= 360.0
End While
While L0 < 0.0
L0 += 360.0
End While
Return L0
' in degrees
End Function
'***********************************************************************/
'* Name: calGeomAnomalySun
'* Type: Function
'* Purpose: calculate the Geometric Mean Anomaly of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* the Geometric Mean Anomaly of the Sun in degrees
'***********************************************************************/
Public Function GemoetricMeanAnomaly(t As Double) As Double
Dim M As Double = 357.52911 + t * (35999.05029 - 0.0001537 * t)
Return M
' in degrees
End Function
'***********************************************************************/
'* Name: EarthOrbitEccentricity
'* Type: Function
'* Purpose: calculate the eccentricity of earth's orbit
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* the unitless eccentricity
'***********************************************************************/
Public Function EarthOrbitEccentricity(t As Double) As Double
Dim e As Double = 0.016708634 - t * (0.000042037 + 0.0000001267 * t)
Return e
' unitless
End Function
'***********************************************************************/
'* Name: SunCentre
'* Type: Function
'* Purpose: calculate the equation of center for the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* in degrees
'***********************************************************************/
Public Function SunCentre(t As Double) As Double
Dim m As Double = GemoetricMeanAnomaly(t)
Dim mrad As Double = Radians(m)
Dim sinm As Double = Math.Sin(mrad)
Dim sin2m As Double = Math.Sin(mrad + mrad)
Dim sin3m As Double = Math.Sin(mrad + mrad + mrad)
Dim C As Double = sinm * (1.914602 - t * (0.004817 + 0.000014 * t)) + sin2m * (0.019993 - 0.000101 * t) + sin3m * 0.000289
Return C
' in degrees
End Function
'***********************************************************************/
'* Name: SunTrueLongitude
'* Type: Function
'* Purpose: calculate the true longitude of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun's true longitude in degrees
'***********************************************************************/
Public Function SunTrueLongitude(t As Double) As Double
Dim l0 As Double = GemoetricMeanLongitude(t)
Dim c As Double = SunCentre(t)
Dim O As Double = l0 + c
Return O
' in degrees
End Function
'***********************************************************************/
'* Name: SunTrueAnomaly
'* Type: Function
'* Purpose: calculate the true anamoly of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun's true anamoly in degrees
'***********************************************************************/
Public Function SunTrueAnomaly(t As Double) As Double
Dim m As Double = GemoetricMeanAnomaly(t)
Dim c As Double = SunCentre(t)
Dim v As Double = m + c
Return v
' in degrees
End Function
'***********************************************************************/
'* Name: SunDistanceAU
'* Type: Function
'* Purpose: calculate the distance to the Sun in AU
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun radius vector in AUs
'***********************************************************************/
Public Function SunDistanceAU(t As Double) As Double
Dim v As Double = SunTrueAnomaly(t)
Dim e As Double = EarthOrbitEccentricity(t)
Dim R As Double = (1.000001018 * (1 - e * e)) / (1 + e * Math.Cos(Radians(v)))
Return R
' in AUs
End Function
'***********************************************************************/
'* Name: SunApparentLongitude
'* Type: Function
'* Purpose: calculate the apparent longitude of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun's apparent longitude in degrees
'***********************************************************************/
Public Function SunApparentLongitude(t As Double) As Double
Dim o As Double = SunTrueLongitude(t)
Dim omega As Double = 125.04 - 1934.136 * t
Dim lambda As Double = o - 0.00569 - 0.00478 * Math.Sin(Radians(omega))
Return lambda
' in degrees
End Function
'***********************************************************************/
'* Name: MeanObliquityOfEcliptic
'* Type: Function
'* Purpose: calculate the mean obliquity of the ecliptic
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* mean obliquity in degrees
'***********************************************************************/
Public Function MeanObliquityOfEcliptic(t As Double) As Double
Dim seconds As Double = 21.448 - t * (46.815 + t * (0.00059 - t * (0.001813)))
Dim e0 As Double = 23.0 + (26.0 + (seconds / 60.0)) / 60.0
Return e0
' in degrees
End Function
'***********************************************************************/
'* Name: calcObliquityCorrection
'* Type: Function
'* Purpose: calculate the corrected obliquity of the ecliptic
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* corrected obliquity in degrees
'***********************************************************************/
Public Function calcObliquityCorrection(t As Double) As Double
Dim e0 As Double = MeanObliquityOfEcliptic(t)
Dim omega As Double = 125.04 - 1934.136 * t
Dim e As Double = e0 + 0.00256 * Math.Cos(Radians(omega))
Return e
' in degrees
End Function
'***********************************************************************/
'* Name: SunRightAscension
'* Type: Function
'* Purpose: calculate the right ascension of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun's right ascension in degrees
'***********************************************************************/
Public Function SunRightAscension(t As Double) As Double
Dim e As Double = calcObliquityCorrection(t)
Dim lambda As Double = SunApparentLongitude(t)
Dim tananum As Double = (Math.Cos(Radians(e)) * Math.Sin(Radians(lambda)))
Dim tanadenom As Double = (Math.Cos(Radians(lambda)))
Dim alpha As Double = Degrees(Math.Atan2(tananum, tanadenom))
Return alpha
' in degrees
End Function
'***********************************************************************/
'* Name: SunDeclination
'* Type: Function
'* Purpose: calculate the declination of the Sun
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* Sun's declination in degrees
'***********************************************************************/
Public Function SunDeclination(t As Double) As Double
Dim e As Double = calcObliquityCorrection(t)
Dim lambda As Double = SunApparentLongitude(t)
Dim sint As Double = Math.Sin(Radians(e)) * Math.Sin(Radians(lambda))
Dim theta As Double = Degrees(Math.Asin(sint))
Return theta
' in degrees
End Function
'***********************************************************************/
'* Name: TrueSolarToMeanSolar
'* Type: Function
'* Purpose: calculate the difference between true solar time and mean
'* solar time
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* Return value:
'* equation of time in minutes of time
'***********************************************************************/
Public Function TrueSolarToMeanSolar(t As Double) As Double
Dim epsilon As Double = calcObliquityCorrection(t)
Dim l0 As Double = GemoetricMeanLongitude(t)
Dim e As Double = EarthOrbitEccentricity(t)
Dim m As Double = GemoetricMeanAnomaly(t)
Dim y As Double = Math.Tan(Radians(epsilon) / 2.0)
y *= y
Dim sin2l0 As Double = Math.Sin(2.0 * Radians(l0))
Dim sinm As Double = Math.Sin(Radians(m))
Dim cos2l0 As Double = Math.Cos(2.0 * Radians(l0))
Dim sin4l0 As Double = Math.Sin(4.0 * Radians(l0))
Dim sin2m As Double = Math.Sin(2.0 * Radians(m))
Dim Etime As Double = y * sin2l0 - 2.0 * e * sinm + 4.0 * e * y * sinm * cos2l0 - 0.5 * y * y * sin4l0 - 1.25 * e * e * sin2m
Return Degrees(Etime) * 4.0
' in minutes of time
End Function
'***********************************************************************/
'* Name: SunriseHourAngle
'* Type: Function
'* Purpose: calculate the hour angle of the Sun at sunrise for the
'* latitude
'* Arguments:
'* lat : latitude of observer in degrees
'* solarDec : declination angle of Sun in degrees
'* Return value:
'* hour angle of sunrise in radians
'***********************************************************************/
Public Function SunriseHourAngle(lat As Double, solarDec As Double) As Double
Dim latRad As Double = Radians(lat)
Dim sdRad As Double = Radians(solarDec)
Dim HAarg As Double = (Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))
Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)))
Return HA
' in radians
End Function
'***********************************************************************/
'* Name: SunsetHourAngle
'* Type: Function
'* Purpose: calculate the hour angle of the Sun at sunset for the
'* latitude
'* Arguments:
'* lat : latitude of observer in degrees
'* solarDec : declination angle of Sun in degrees
'* Return value:
'* hour angle of sunset in radians
'***********************************************************************/
Public Function SunsetHourAngle(lat As Double, solarDec As Double) As Double
Dim latRad As Double = Radians(lat)
Dim sdRad As Double = Radians(solarDec)
Dim HAarg As Double = (Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad))
Dim HA As Double = (Math.Acos(Math.Cos(Radians(90.833)) / (Math.Cos(latRad) * Math.Cos(sdRad)) - Math.Tan(latRad) * Math.Tan(sdRad)))
Return -HA
' in radians
End Function
'***********************************************************************/
'* Name: SunRiseUTC
'* Type: Function
'* Purpose: calculate the Universal Coordinated Time (UTC) of sunrise
'* for the given day at the given location on earth
'* Arguments:
'* julian : julian day
'* latitude : latitude of observer in degrees
'* longitude : longitude of observer in degrees
'* Return value:
'* time in minutes from zero Z
'***********************************************************************/
'Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double
' Dim t As Double = JulianCenturies(julian)
' ' *** Find the time of solar noon at the location, and use
' ' that declination. This is better than start of the
' ' Julian day
' Dim noonmin As Double = SolarNoonUTC(t, longitude)
' Dim tnoon As Double = JulianCenturies(julian + noonmin / 1440.0)
' ' *** First pass to approximate sunrise (using solar noon)
' Dim eqTime As Double = TrueSolarToMeanSolar(tnoon)
' Dim solarDec As Double = SunDeclination(tnoon)
' Dim hourAngle As Double = SunriseHourAngle(latitude, solarDec)
' Dim delta As Double = longitude - Degrees(hourAngle)
' Dim timeDiff As Double = 4 * delta
' ' in minutes of time
' Dim timeUTC As Double = 720 + timeDiff - eqTime
' ' in minutes
' ' alert("eqTime = " + eqTime + "\nsolarDec = " + solarDec + "\ntimeUTC = " + timeUTC);
' ' *** Second pass includes fractional julianay in gamma calc
' Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) + timeUTC / 1440.0)
' eqTime = TrueSolarToMeanSolar(newt)
' solarDec = SunDeclination(newt)
' hourAngle = SunriseHourAngle(latitude, solarDec)
' delta = longitude - Degrees(hourAngle)
' timeDiff = 4 * delta
' timeUTC = 720 + timeDiff - eqTime
' ' in minutes
' ' alert("eqTime = " + eqTime + "\nsolarDec = " + solarDec + "\ntimeUTC = " + timeUTC);
' Return timeUTC
'End Function
'***********************************************************************/
'* Name: SolarNoonUTC
'* Type: Function
'* Purpose: calculate the Universal Coordinated Time (UTC) of solar
'* noon for the given day at the given location on earth
'* Arguments:
'* t : number of Julian centuries since J2000.0
'* longitude : longitude of observer in degrees
'* Return value:
'* time in minutes from zero Z
'***********************************************************************/
Public Function SolarNoonUTC(t As Double, longitude As Double) As Double
' First pass uses approximate solar noon to calculate eqtime
Dim tnoon As Double = JulianCenturies(JulianDayFromJulianCentury(t) + longitude / 360.0)
Dim eqTime As Double = TrueSolarToMeanSolar(tnoon)
Dim solNoonUTC As Double = 720 + (longitude * 4) - eqTime
' min
Dim newt As Double = JulianCenturies(JulianDayFromJulianCentury(t) - 0.5 + solNoonUTC / 1440.0)
eqTime = TrueSolarToMeanSolar(newt)
' double solarNoonDec = SunDeclination(newt);
solNoonUTC = 720 + (longitude * 4) - eqTime
' min
Return solNoonUTC
End Function
'***********************************************************************/
'* Name: SunSetUTC
'* Type: Function
'* Purpose: calculate the Universal Coordinated Time (UTC) of sunset
'* for the given day at the given location on earth
'* Arguments:
'* julian : julian day
'* latitude : latitude of observer in degrees
'* longitude : longitude of observer in degrees
'* Return value:
'* time in minutes from zero Z
'***********************************************************************/
Public Function SunSetUTC(julian As Double, latitude As Double, longitude As Double) As Double
Dim t = JulianCenturies(julian)
Dim eqTime = TrueSolarToMeanSolar(t)
Dim solarDec = SunDeclination(t)
Dim hourAngle = SunriseHourAngle(latitude, solarDec)
hourAngle = -hourAngle
Dim delta = longitude + Degrees(hourAngle)
Dim timeUTC = 720 - (4.0 * delta) - eqTime
' in minutes
Return timeUTC
End Function
Public Function SunRiseUTC(julian As Double, latitude As Double, longitude As Double) As Double
Dim t = JulianCenturies(julian)
Dim eqTime = TrueSolarToMeanSolar(t)
Dim solarDec = SunDeclination(t)
Dim hourAngle = SunriseHourAngle(latitude, solarDec)
Dim delta = longitude + Degrees(hourAngle)
Dim timeUTC = 720 - (4.0 * delta) - eqTime
' in minutes
Return timeUTC
End Function
Public Function getTimeString(time As Double, timezone As Integer, julian As Double, dst As Boolean) As String
Dim timeLocal = time + (timezone * 60.0)
Dim riseT = JulianCenturies(julian + time / 1440.0)
timeLocal += (If((dst), 60.0, 0.0))
Return getTimeString(timeLocal)
End Function
Public Function getDateTime(time As Double, timezone As Integer, [date] As DateTime, dst As Boolean) As System.Nullable(Of DateTime)
Dim julian As Double = JulianDay([date])
Dim timeLocal = time + (timezone * 60.0)
Dim riseT = JulianCenturies(julian + time / 1440.0)
timeLocal += (If((dst), 60.0, 0.0))
Return getDateTime(timeLocal, [date])
End Function
Private Function getTimeString(minutes As Double) As String
Dim output As String = ""
If (minutes >= 0) AndAlso (minutes < 1440) Then
Dim floatHour = minutes / 60.0
Dim hour = Math.Floor(floatHour)
Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour))
Dim minute = Math.Floor(floatMinute)
Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute))
Dim second = Math.Floor(floatSec + 0.5)
If second > 59 Then
second = 0
minute += 1
End If
If (second >= 30) Then
minute += 1
End If
If minute > 59 Then
minute = 0
hour += 1
End If
output = [String].Format("{0:00}:{1:00}", hour, minute)
Else
Return "error"
End If
Return output
End Function
Private Function getDateTime(minutes As Double, [date] As DateTime) As System.Nullable(Of DateTime)
Dim retVal As System.Nullable(Of DateTime) = Nothing
If (minutes >= 0) AndAlso (minutes < 1440) Then
Dim floatHour = minutes / 60.0
Dim hour = Math.Floor(floatHour)
Dim floatMinute = 60.0 * (floatHour - Math.Floor(floatHour))
Dim minute = Math.Floor(floatMinute)
Dim floatSec = 60.0 * (floatMinute - Math.Floor(floatMinute))
Dim second = Math.Floor(floatSec + 0.5)
If second > 59 Then
second = 0
minute += 1
End If
If (second >= 30) Then
minute += 1
End If
If minute > 59 Then
minute = 0
hour += 1
End If
Return New DateTime([date].Year, [date].Month, [date].Day, CInt(hour), CInt(minute), CInt(second))
Else
Return retVal
End If
End Function
End Module
Commencez avec cette information:
J'utilise ceci pour écrire un script Ruby qui est encore en préparation. J'ai du mal à comprendre les dates en plusieurs parties de Julien.
Une chose est claire, c’est que vous devez choisir le temps de transit solaire exact. Puis soustrayez et ajoutez semi_diurnal_arc = acos (cos_omega) qui repose sur En fonction de votre latitude et de la déclinaison solaire. Oh! Et assurez-vous d'inclure le centre solaire Et la réfraction de la terre. Il semble que cette terre est tout à fait le magicien.
J'ai fait un script rapide Python pour le faire: SunriseSunsetCalculator
Je n'ai pas encore emballé cela dans une classe, mais cela peut être utile pour d'autres.
Edit: Open source est génial, car engager le script de base, quelqu'un l’a enveloppé dans un module et un autre a ajouté une interface client! Merci à mbideau et nfischer pour leurs contributions!
Vous avez besoin d'une formule qui inclut l'équation du temps pour tenir compte de l'orbite excentrique du système lunaire terrestre autour du Soleil. Vous devez utiliser des coordonnées avec des points de référence appropriés tels que WGS84 ou NAD27 ou quelque chose comme ça. Vous devez utiliser le calendrier JULIAN et non celui que nous utilisons quotidiennement pour obtenir des temps corrects. Ce n'est pas une chose facile à deviner en une seconde. J'aimerais avoir le temps chez moi où la longueur de l'ombre est égale à la hauteur. Cela devrait se produire deux fois par jour lorsque le soleil est élevé à 60 degrés au-dessus de l'horizon avant et après midi. En outre, pour autant que je sache, il vous suffit d’ajouter exactement un jour par an pour obtenir une heure sidérale. Par conséquent, si vous souhaitez augmenter votre fréquence d’horloge X 366,25/365,25, vous pouvez désormais disposer d’une horloge sidérale au lieu d’une horloge civile ??? "MATH est la langue dans laquelle quelqu'un de puissant a écrit l'univers"
Une autre bonne implémentation de JS est suncalc .
Le nombre de lignes de code étant gérable, le portage dans d'autres langages (C #) est certainement possible.
J'ai testé ce paquet de nuget dans UWP.
https://www.nuget.org/packages/SolarCalculator/
La documentation est un peu sommaire, et est ici:
https://github.com/porrey/Solar-Calculator
Vous pouvez l'utiliser pour obtenir le lever du soleil, étant donné
la = latitude; et lo = longitude; pour votre région:
SolarTimes solarTimes = new SolarTimes(DateTime.Now, la, lo);
DateTime sr = solarTimes.Sunrise;
DateTime dt = Convert.ToDateTime(sr);
textblockb.Text = dt.ToString("h:mm:ss");
Vous pouvez l'installer dans Visual Studio à l'aide du gestionnaire PM.
Install-Package SolarCalculator -Version 2.0.2
ou en recherchant SolarCalculator dans la bibliothèque Visual Studio "Manage NuGet Packages".
Si vous préférez un service externe, vous pouvez utiliser cette API Nice et gratuite de l'heure du lever et du coucher du soleil: http://sunrise-sunset.org/api
Je l'utilise depuis plusieurs projets et cela fonctionne très bien, les données semblent très précises. Il suffit de faire une requête HTTP GET à http://api.sunrise-sunset.org/json
Paramètres acceptés:
- lat: Latitude en degrés décimaux. Champs obligatoires.
- lng: Longitude en degrés décimaux. Champs obligatoires.
- date: date au format AAAA-MM-JJ. Accepte également les autres formats de date et même les formats de date relatifs. S'il n'est pas présent, la date par défaut est la date actuelle. Optionnel.
- callback: nom de la fonction de rappel pour la réponse JSONP. Optionnel.
- formaté: 0 ou 1 (1 par défaut). Les valeurs de temps en réponse seront exprimées conformément à la norme ISO 8601 et day_length sera exprimé en secondes. Optionnel.
La réponse inclut les heures de lever et de coucher du soleil, ainsi que les heures du crépuscule.
Oui quitter quelques-uns.
Quelques liens pour des motifs.
http://williams.best.vwh.net/sunrise_sunset_example.htm
http://www.codeproject.com/Articles/29306/C-Class-for-Calculating-Sunrise-and-Sunset-Times
https://Gist.github.com/cstrahan/767532
http://pointofint.blogspot.com/2014/06/sunrise-and-sunset-in-c.html
http://yaddb.blogspot.com/2013/01/how-to-calculate-sunrise-and-sunset.html
https://forums.asp.net/t/1810934.aspx?Sunrise+and+Sunset+timings+Calculation+
http://www.ip2location.com/tutorials/display-sunrise-sunset-time-using-csharp-and-mysql-database
http://fr.pudn.com/downloads270/sourcecode/windows/csharp/detail1235934_en.html
http://regator.com/p/25716249/c_class_for_calculating_sunrise_and_sunset_times
http://forums.xkcd.com/viewtopic.php?t=102253
http://www.redrok.com/solar_position_algorithm.pdf
http://sidstation.loudet.org/sunazimuth-en.xhtml
https://sourceforge.net/directory/os:windows/?q=sunrise/set%20times
https://www.nuget.org/packages/SolarCalculator/
http://www.Grasshopper3d.com/forum/topics/solar-calculation-plugin
et c’était un projet que j’avais fait pour Planet Source Code il ya longtemps, mais heureusement je l’ai sauvegardé ailleurs car ce site avait perdu des données.
https://github.com/DouglasAllen/SunTimes.VSCS.Net
utilise ce Gist plus
https://Gist.github.com/DouglasAllen/c682e4c412a0b9d8f536b014c1766f20
Maintenant, pour une brève explication de la technique pour le faire.
Tout d’abord, quel que soit le jour où vous avez besoin d’un vrai midi solaire ou d’un transit pour votre région.
Cela prend en compte votre longitude locale. Il peut être converti en un temps simplement en le divisant par 15.
C'est combien de temps plus tard vous êtes de l'heure de la zone zoulou ou de la longitude zéro.
Cela commence à 12:00 PM ou à midi.
Et sur votre temps calculé à partir de la longitude.
Maintenant la partie difficile. Vous avez besoin d'un moyen de calculer l'équation du temps.
C’est une différence de temps causée par l’inclinaison de la Terre et son orbite autour du Soleil.
Cela vous donnera une idée ... https://en.wikipedia.org/wiki/Equation_of_time
Mais ils ont une formule qui est beaucoup plus facile .... https://en.wikipedia.org/wiki/Sunrise_equation
Ce mec a des livres que beaucoup de gens vont acheter ou acheter. :-D https://en.wikipedia.org/wiki/Jean_Meeus
Utilisez votre premier calcul pour votre transit solaire moyen et calculez un JDN ... https://en.wikipedia.org/wiki/Julian_day
Ceci est utilisé par toutes les formules d'angle comme une époque du siècle julien https://en.wikipedia.org/wiki/Julian_year_(astronomy)
https://en.wikipedia.org/wiki/Epoch_(astronomy)
C'est essentiellement votre JDN moins l'époque, tels que J2000 ou 2451545.0 Tous divisés par 36525.0 pour vous donner le siècle julien ou t Qui est utilisé pour la plupart des formules qui ont t comme paramètre. Parfois, Mille millénaire est utilisé. Dans ce cas, c'est 3652500.0
L'astuce consiste à trouver les formules d'angle qui vous aident à résoudre l'équation du temps.
Ensuite, vous obtenez votre véritable transit solaire et soustrayez la demi-journée ou ajoutez la demi-journée de soleil correspondant à votre position. Vous les trouverez dans les réponses et le logiciel.
Une fois que vous obtenez quelque chose, vous pouvez le comparer à une recherche des temps ou des calculatrices en ligne.
J'espère que cela suffit pour vous aider. Il y a des bibliothèques partout mais ce n'est pas si difficile de créer la vôtre. Je l’ai fait mais c’est en Ruby. Cela pourrait s’avérer utile .... https://github.com/DouglasAllen/gem-equationoftime
bonne chance!