maier_st/OxyPlot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Neuerstellung

Browse Source 
- Quelle: https://github.com/oxyplot/oxyplot
This commit is contained in:
maier_st
2023-09-02 09:24:59 +02:00
commit 9520c1fa4a
810 changed files with 117869 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

331
Source/Examples/ExampleLibrary/Utilities/PlotModelUtilities.cs Normal file
View File

@@ -0,0 +1,331 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="PlotModelUtilities.cs" company="OxyPlot">
// Copyright (c) 2014 OxyPlot contributors
// </copyright>
// <summary>
// Provides utility functions for PlotModel used in examples.
// </summary>
// --------------------------------------------------------------------------------------------------------------------
namespace ExampleLibrary.Utilities
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using OxyPlot;
using OxyPlot.Axes;
using OxyPlot.Series;
/// <summary>
/// Provides utility functions for PlotModel used in examples.
/// </summary>
public static class PlotModelUtilities
{
private const string XAXIS_KEY = "x";
private const string YAXIS_KEY = "y";
/// <summary>
/// Lists all XYAxisSeries from the core library that are NOT reversible.
/// </summary>
private static readonly HashSet<Type> NonReversibleSeriesTypes = new HashSet<Type>
{
};
/// <summary>
/// Lists all Annotations that need axes and are NOT reversible.
/// </summary>
private static readonly HashSet<Type> NonReversibleDataSpaceAnnotationTypes = new HashSet<Type>
{
typeof(TileMapAnnotation),
};
/// <summary>
/// Lists all XYAxisSeries from the core library that are NOT transposable.
/// </summary>
private static readonly HashSet<Type> NonTransposableSeriesTypes = new HashSet<Type>
{
typeof(CandleStickAndVolumeSeries),
typeof(OldCandleStickSeries),
};
/// <summary>
/// Lists all Annotations that need axes and are NOT transposable.
/// </summary>
private static readonly HashSet<Type> NonTransposableDataSpaceAnnotationTypes = new HashSet<Type>
{
};
/// <summary>
/// Returns a value indicating whether a plot model is reversible.
/// </summary>
/// <param name="model">The plot model.</param>
/// <returns>True if the plot model in reversible; false otherwise.</returns>
public static bool IsReversible(this PlotModel model)
{
return (model.Axes.Count > 0 || model.Series.Count > 0)
&& model.Axes.All(a => a.Position != AxisPosition.None)
&& model.Series.All(s =>
{
var type = s.GetType();
return s is XYAxisSeries
&& type.GetTypeInfo().Assembly == typeof(PlotModel).GetTypeInfo().Assembly
&& !NonReversibleSeriesTypes.Contains(type);
})
&& model.Annotations.All(a =>
{
var type = a.GetType();
return !NonReversibleDataSpaceAnnotationTypes.Contains(type);
});
}
/// <summary>
/// Returns a value indicating whether a plot model is transposable.
/// </summary>
/// <param name="model">The plot model.</param>
/// <returns>True if the plot model in transposable; false otherwise.</returns>
public static bool IsTransposable(this PlotModel model)
{
return (model.Axes.Count > 0 || model.Series.Count > 0)
&& model.Axes.All(a => a.Position != AxisPosition.None)
&& model.Series.All(s => s is ITransposablePlotElement && !NonTransposableSeriesTypes.Contains(s.GetType()))
&& model.Annotations.All(a => a is ITransposablePlotElement && !NonTransposableDataSpaceAnnotationTypes.Contains(a.GetType()));
}
/// <summary>
/// Reverses the X Axis of a PlotModel. The given PlotModel is mutated and returned for convenience.
/// </summary>
/// <param name="model">The PlotModel.</param>
/// <returns>The PlotModel with reversed X Axis.</returns>
public static PlotModel ReverseXAxis(this PlotModel model)
{
if (!string.IsNullOrEmpty(model.Title))
{
model.Title += " (reversed X Axis)";
}
var foundXAxis = false;
foreach (var axis in model.Axes)
{
switch (axis.Position)
{
case AxisPosition.Bottom:
axis.StartPosition = 1 - axis.StartPosition;
axis.EndPosition = 1 - axis.EndPosition;
foundXAxis = true;
break;
case AxisPosition.Left:
case AxisPosition.Right:
case AxisPosition.Top:
case AxisPosition.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (!foundXAxis)
{
model.Axes.Add(new LinearAxis { Position = AxisPosition.Bottom, StartPosition = 1, EndPosition = 0});
}
return model;
}
/// <summary>
/// Reverses the Y Axis of a PlotModel. The given PlotModel is mutated and returned for convenience.
/// </summary>
/// <param name="model">The PlotModel.</param>
/// <returns>The PlotModel with reversed Y Axis.</returns>
public static PlotModel ReverseYAxis(this PlotModel model)
{
if (!string.IsNullOrEmpty(model.Title))
{
model.Title += " (reversed Y Axis)";
}
var foundYAxis = false;
foreach (var axis in model.Axes)
{
switch (axis.Position)
{
case AxisPosition.Left:
axis.StartPosition = 1 - axis.StartPosition;
axis.EndPosition = 1 - axis.EndPosition;
foundYAxis = true;
break;
case AxisPosition.Bottom:
case AxisPosition.Right:
case AxisPosition.Top:
case AxisPosition.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (!foundYAxis)
{
model.Axes.Add(new LinearAxis { Position = AxisPosition.Left, StartPosition = 1, EndPosition = 0});
}
return model;
}
/// <summary>
/// Reverses X and Y Axes of a PlotModel. The given PlotModel is mutated and returned for convenience.
/// </summary>
/// <param name="model">The PlotModel.</param>
/// <returns>The PlotModel with reversed X and Y Axis.</returns>
public static PlotModel ReverseXandYAxes(this PlotModel model)
{
var title = model.Title;
if (!string.IsNullOrEmpty(title))
{
title += " (reversed both Axes)";
}
model = model.ReverseXAxis().ReverseYAxis();
model.Title = title;
return model;
}
/// <summary>
/// Reverses all axes of a PlotModel. The given PlotModel is mutated and returned for convenience.
/// </summary>
/// <param name="model">The PlotModel.</param>
/// <returns>The PlotModel with reversed axes.</returns>
public static PlotModel ReverseAllAxes(this PlotModel model)
{
if (!string.IsNullOrEmpty(model.Title))
{
model.Title += " (reversed all Axes)";
}
// Update plot to generate default axes etc.
((IPlotModel)model).Update(false);
foreach (var axis in model.Axes)
{
switch (axis.Position)
{
case AxisPosition.Left:
case AxisPosition.Bottom:
case AxisPosition.Right:
case AxisPosition.Top:
axis.StartPosition = 1 - axis.StartPosition;
axis.EndPosition = 1 - axis.EndPosition;
break;
case AxisPosition.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return model;
}
/// <summary>
/// Transposes a PlotModel. The given PlotModel is mutated and returned for convenience.
/// </summary>
/// <param name="model">The PlotModel.</param>
/// <returns>The transposed PlotModel.</returns>
public static PlotModel Transpose(this PlotModel model)
{
if (!string.IsNullOrEmpty(model.Title))
{
model.Title += " (transposed)";
}
// Update plot to generate default axes etc.
((IPlotModel)model).Update(false);
foreach (var axis in model.Axes)
{
switch (axis.Position)
{
case AxisPosition.Bottom:
axis.Position = AxisPosition.Left;
break;
case AxisPosition.Left:
axis.Position = AxisPosition.Bottom;
break;
case AxisPosition.Right:
axis.Position = AxisPosition.Top;
break;
case AxisPosition.Top:
axis.Position = AxisPosition.Right;
break;
case AxisPosition.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
foreach (var annotation in model.Annotations)
{
if (annotation.XAxis != null && annotation.XAxisKey == null)
{
if (annotation.XAxis.Key == null)
{
annotation.XAxis.Key = XAXIS_KEY;
}
annotation.XAxisKey = annotation.XAxis.Key;
}
if (annotation.YAxis != null && annotation.YAxisKey == null)
{
if (annotation.YAxis.Key == null)
{
annotation.YAxis.Key = YAXIS_KEY;
}
annotation.YAxisKey = annotation.YAxis.Key;
}
}
foreach (var series in model.Series.OfType<XYAxisSeries>())
{
if (series.XAxisKey == null)
{
if (series.XAxis == null) // this can happen if the series is invisible initially
{
series.XAxisKey = XAXIS_KEY;
}
else
{
if (series.XAxis.Key == null)
{
series.XAxis.Key = XAXIS_KEY;
}
series.XAxisKey = series.XAxis.Key;
}
}
if (series.YAxisKey == null)
{
if (series.YAxis == null)
{
series.YAxisKey = YAXIS_KEY;
}
else
{
if (series.YAxis.Key == null)
{
series.YAxis.Key = YAXIS_KEY;
}
series.YAxisKey = series.YAxis.Key;
}
}
}
return model;
}
}
}

227
Source/Examples/ExampleLibrary/Utilities/Sun.cs Normal file
View File

@@ -0,0 +1,227 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Sun.cs" company="OxyPlot">
// Copyright (c) 2014 OxyPlot contributors
// </copyright>
// <summary>
// Calculation of sunrise/sunset
// </summary>
// --------------------------------------------------------------------------------------------------------------------
namespace ExampleLibrary
{
using System;
/// <summary>
/// Calculation of sunrise/sunset
/// </summary>
/// <remarks>http://williams.best.vwh.net/sunrise_sunset_algorithm.htm
/// based on code by Huysentruit Wouter, Fastload-Media.be</remarks>
public static class Sun
{
private static double Deg2Rad(double angle)
{
return Math.PI * angle / 180.0;
}
private static double Rad2Deg(double angle)
{
return 180.0 * angle / Math.PI;
}
private static double FixValue(double value, double min, double max)
{
while (value < min)
{
value += max - min;
}
while (value >= max)
{
value -= max - min;
}
return value;
}
public static DateTime Calculate(DateTime date, double latitude, double longitude, bool sunrise, Func<DateTime, DateTime> utcToLocalTime, double zenith = 90.5)
{
// 1. first calculate the day of the year
int n = date.DayOfYear;
// 2. convert the longitude to hour value and calculate an approximate time
double lngHour = longitude / 15.0;
double t;
if (sunrise)
{
t = n + ((6.0 - lngHour) / 24.0);
}
else
{
t = n + ((18.0 - lngHour) / 24.0);
}
// 3. calculate the Sun's mean anomaly
double m = (0.9856 * t) - 3.289;
// 4. calculate the Sun's true longitude
double l = m + (1.916 * Math.Sin(Deg2Rad(m))) + (0.020 * Math.Sin(Deg2Rad(2 * m))) + 282.634;
l = FixValue(l, 0, 360);
// 5a. calculate the Sun's right ascension
double ra = Rad2Deg(Math.Atan(0.91764 * Math.Tan(Deg2Rad(l))));
ra = FixValue(ra, 0, 360);
// 5b. right ascension value needs to be in the same quadrant as L
double lquadrant = Math.Floor(l / 90.0) * 90.0;
double raquadrant = Math.Floor(ra / 90.0) * 90.0;
ra = ra + (lquadrant - raquadrant);
// 5c. right ascension value needs to be converted into hours
ra = ra / 15.0;
// 6. calculate the Sun's declination
double sinDec = 0.39782 * Math.Sin(Deg2Rad(l));
double cosDec = Math.Cos(Math.Asin(sinDec));
// 7a. calculate the Sun's local hour angle
double cosH = (Math.Cos(Deg2Rad(zenith)) - (sinDec * Math.Sin(Deg2Rad(latitude)))) /
(cosDec * Math.Cos(Deg2Rad(latitude)));
// 7b. finish calculating H and convert into hours
double h;
if (sunrise)
{
h = 360.0 - Rad2Deg(Math.Acos(cosH));
}
else
{
h = Rad2Deg(Math.Acos(cosH));
}
h = h / 15.0;
// 8. calculate local mean time of rising/setting
double localMeanTime = h + ra - (0.06571 * t) - 6.622;
// 9. adjust back to UTC
double utc = localMeanTime - lngHour;
// 10. convert UT value to local time zone of latitude/longitude
date = new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, DateTimeKind.Utc);
var utctime = date.AddHours(utc);
var localTime = utcToLocalTime(utctime);
utc = (localTime - date).TotalHours;
utc = FixValue(utc, 0, 24);
return date.AddHours(utc);
}
}
/*
Sunrise/Sunset Algorithm
Source:
Almanac for Computers, 1990
published by Nautical Almanac Office
United States Naval Observatory
Washington, DC 20392
Inputs:
day, month, year: date of sunrise/sunset
latitude, longitude: location for sunrise/sunset
zenith: Sun's zenith for sunrise/sunset
offical = 90 degrees 50'
civil = 96 degrees
nautical = 102 degrees
astronomical = 108 degrees
NOTE: longitude is positive for East and negative for West
NOTE: the algorithm assumes the use of a calculator with the
trig functions in "degree" (rather than "radian") mode. Most
programming languages assume radian arguments, requiring back
and forth convertions. The factor is 180/pi. So, for instance,
the equation RA = atan(0.91764 * tan(L)) would be coded as RA
= (180/pi)*atan(0.91764 * tan((pi/180)*L)) to give a degree
answer with a degree input for L.
1. first calculate the day of the year
N1 = floor(275 * month / 9)
N2 = floor((month + 9) / 12)
N3 = (1 + floor((year - 4 * floor(year / 4) + 2) / 3))
N = N1 - (N2 * N3) + day - 30
2. convert the longitude to hour value and calculate an approximate time
lngHour = longitude / 15
if rising time is desired:
t = N + ((6 - lngHour) / 24)
if setting time is desired:
t = N + ((18 - lngHour) / 24)
3. calculate the Sun's mean anomaly
M = (0.9856 * t) - 3.289
4. calculate the Sun's true longitude
L = M + (1.916 * sin(M)) + (0.020 * sin(2 * M)) + 282.634
NOTE: L potentially needs to be adjusted into the range [0,360) by adding/subtracting 360
5a. calculate the Sun's right ascension
RA = atan(0.91764 * tan(L))
NOTE: RA potentially needs to be adjusted into the range [0,360) by adding/subtracting 360
5b. right ascension value needs to be in the same quadrant as L
Lquadrant = (floor( L/90)) * 90
RAquadrant = (floor(RA/90)) * 90
RA = RA + (Lquadrant - RAquadrant)
5c. right ascension value needs to be converted into hours
RA = RA / 15
6. calculate the Sun's declination
sinDec = 0.39782 * sin(L)
cosDec = cos(asin(sinDec))
7a. calculate the Sun's local hour angle
cosH = (cos(zenith) - (sinDec * sin(latitude))) / (cosDec * cos(latitude))
if (cosH > 1)
the sun never rises on this location (on the specified date)
if (cosH < -1)
the sun never sets on this location (on the specified date)
7b. finish calculating H and convert into hours
if if rising time is desired:
H = 360 - acos(cosH)
if setting time is desired:
H = acos(cosH)
H = H / 15
8. calculate local mean time of rising/setting
T = H + RA - (0.06571 * t) - 6.622
9. adjust back to UTC
UT = T - lngHour
NOTE: UT potentially needs to be adjusted into the range [0,24) by adding/subtracting 24
10. convert UT value to local time zone of latitude/longitude
localT = UT + localOffset
*/
}