public virtual void Transform(IAxis axis, IEnumerable<ChartLine> lines)
{
foreach (var line in lines)
{
Transform(axis, line);
}
}
public virtual void Transform(IAxis axis, IEnumerable<ChartPoint> points)
{
foreach (var point in points)
{
Transform(axis, point);
}
}
public virtual void Transform(IAxis axis, IEnumerable<IAxis> dependentAxes)
{
foreach (var ax in dependentAxes)
{
Transform(axis, ax);
}
}
public virtual void Transform(IAxis axis, ChartLine line)
{
if (line.Segments.Count > 0)
Transform(axis, line.Segments[0].PointX);
foreach (var segment in line.Segments)
{
Transform(axis, segment.PointY);
}
}
void mPlugin_AxisAdded(IAxis axis)
{
AxisPanel panel = new AxisPanel(axis, AxisBinding.X, AxisBinding.Y, AxisBinding.Z, AxisBinding.Pitch, AxisBinding.Yaw, AxisBinding.Z);
panel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
panel.Width = axesBox.Width - PADDING * 2;
axesBox.Controls.Add(panel);
panel.SizeChanged += new EventHandler(panel_SizeChanged);
RepositionPanels();
}
private void mAxis_AxisAdded(IAxis axis)
{
positivePulldown.Items.Add(axis);
negativePulldown.Items.Add(axis);
if (axis == mAxis.Positive)
positivePulldown.SelectedItem = axis;
if (axis == mAxis.Negative)
negativePulldown.SelectedItem = axis;
}
void mInput_AxisAdded(IAxis axis)
{
AxisPanel panel = new AxisPanel(axis, AxisBinding.MouseX, AxisBinding.MouseY);
panel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
panel.Width = axesBox.Width - PADDING * 2;
axesBox.Controls.Add(panel);
panel.SizeChanged += new EventHandler(panel_SizeChanged);
RepositionPanels();
}
public void Draw(Chart2DSpriteContainer sprites, IAxis axis1, IAxis axis2, Vector2 offset)
{
if (this.HorizontalLines != null)
foreach (var line in this.HorizontalLines)
line.Draw(sprites, axis1, axis2, offset, Vector2.UnitX, Vector2.UnitY);
if (this.VerticalLines != null)
foreach (var line in this.VerticalLines)
line.Draw(sprites, axis2, axis1, offset, Vector2.UnitY, Vector2.UnitX);
}
/// <summary>
/// Retrieves the value for a given access from a data point.
/// </summary>
/// <param name="dataPoint">The data point to retrieve the value from.</param>
/// <param name="axis">The axis to retrieve the value for.</param>
/// <returns>A function that returns a value appropriate for the axis
/// when provided a DataPoint.</returns>
protected virtual object GetActualDataPointAxisValue(DataPoint dataPoint, IAxis axis)
{
if (axis == InternalActualIndependentAxis)
{
return dataPoint.ActualIndependentValue;
}
else if (axis == InternalActualDependentAxis)
{
return dataPoint.ActualDependentValue;
}
return null;
}
public void ConfigureAxis(IAxis axis, Core core)
{
if (core != null && axis is ITickListener)
(axis as ITickListener).Init(core);
if (axis is ConstrainedAxis) {
ConstrainedAxis ax = axis as ConstrainedAxis;
ax.Deadzone.Value = GetDeadzone(axis.Name);
ax.Scale.Value = GetScale(axis.Name);
}
if (axis.Binding == AxisBinding.NotSet)
axis.Binding = GetBinding(axis.Name);
}
/// <summary>
/// Returns the actual margin for a given framework element and axis.
/// </summary>
/// <param name="element">The framework element.</param>
/// <param name="axis">The axis along which to return the margin.
/// </param>
/// <returns>The margin for a given framework element and axis.
/// </returns>
public static double GetActualMargin(this FrameworkElement element, IAxis axis)
{
double length = 0.0;
if (axis.Orientation == AxisOrientation.X)
{
length = element.ActualWidth;
}
else if (axis.Orientation == AxisOrientation.Y)
{
length = element.ActualHeight;
}
return length / 2.0;
}
/// <summary>
/// Returns the margin for a given framework element and axis.
/// </summary>
/// <param name="element">The framework element.</param>
/// <param name="axis">The axis along which to return the margin.
/// </param>
/// <returns>The margin for a given framework element and axis.
/// </returns>
public static double GetMargin(this FrameworkElement element, IAxis axis)
{
double length = 0.0;
if (axis.Orientation == AxisOrientation.X)
{
length = !double.IsNaN(element.Width) ? element.Width : element.ActualWidth;
}
else if (axis.Orientation == AxisOrientation.Y)
{
length = !double.IsNaN(element.Height) ? element.Height : element.ActualHeight;
}
return length / 2.0;
}
private void UpdateVerticalTicks(IAxis axis)
{
axisGrid.BeginTicksUpdate();
if (axis != null)
{
axisGrid.VerticalTicks = axis.ScreenTicks;
axisGrid.MinorVerticalTicks = axis.MinorScreenTicks;
}
else
{
axisGrid.VerticalTicks = null;
axisGrid.MinorHorizontalTicks = null;
}
axisGrid.EndTicksUpdate();
}
/// <summary>
/// Constructs a new vertical CRS.
/// </summary>
/// <param name="name">The name of the CRS.</param>
/// <param name="datum">The datum the CRS is based on.</param>
/// <param name="linearUnit">The linear unit for the CRS.</param>
/// <param name="axis">The axis for the linear CRS.</param>
/// <param name="authority">The authority.</param>
public OgcCrsVertical(
string name,
IDatum datum,
IUnit linearUnit,
IAxis axis,
IAuthorityTag authority
)
: base(name, authority)
{
if(datum == null) throw new ArgumentNullException("datum");
if(linearUnit == null) throw new ArgumentNullException("linearUnit");
if(axis == null) throw new ArgumentNullException("axis");
Contract.Requires(name != null);
Datum = datum;
Unit = linearUnit;
Axis = axis;
}
public AxisPanel(IAxis axis, params AxisBinding[] ignoredBindings)
: this(ignoredBindings)
{
mAxis = axis;
bindingDropdown.SelectedItem = axis.Binding;
mainGroup.Text = axis.Name;
UserControl control = mAxis.ControlPanel;
mExpandedSize = MinimumSize.Height + control.Height;
Height = editBox.Checked ? mExpandedSize : MinimumSize.Height;
control.Visible = editBox.Checked;
control.Width = configPanel.Width;
control.Dock = DockStyle.Fill;
//control.Anchor = AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top;
configPanel.Controls.Add(control);
}
public void Draw(Chart2DSpriteContainer sprites, IAxis parallelAxis, IAxis perpendicularAxis,
Vector2 offset, Vector2 direction, Vector2 axisUnit)
{
sprites.Color = this.color;
var minOffset = offset + direction * (float)parallelAxis.DataToChart(parallelAxis.MinValue);
var maxOffset = offset + direction * (float)parallelAxis.DataToChart(parallelAxis.MaxValue);
int minI = this.repeat ? (int)((perpendicularAxis.MinValue - this.StartValue) / this.interval) : 0;
int maxI = this.repeat ? (int)((perpendicularAxis.MaxValue - this.StartValue) / this.interval) : 0;
for (int i = minI; i <= maxI; i++)
{
var position = axisUnit * (float)perpendicularAxis.DataToChart(this.StartValue + this.interval * i);
sprites.DrawLine(
minOffset + position,
maxOffset + position,
sprites.ThinLineWidth);
}
}
private void RefreshChartCycling()
{
// Initialize the charts, dataseries, and variables
IAxis axis = scoreChart.YAxis;
ChartDataSeries dsFactor = new ChartDataSeries(scoreChart, axis);
ChartDataSeries dsFactorLine = new ChartDataSeries(scoreChart, axis);
PointF point = new PointF();
double factor = GlobalSettings.Instance.CyclingFactor;
double offset = GlobalSettings.Instance.CyclingOffset;
// Populate the data series. Cycling only scores on uphills
for (int i = 0; i <= 100; i++)
{
point.X = (float)i;
point.Y = (float)((factor * i) + offset);
dsFactor.Points.Add(i, point);
}
// Prepare the axis and the dataseries
axis.Label = Resources.Strings.Label_Score + "/km";
scoreChart.XAxis.Label = CommonResources.Text.LabelGrade;
scoreChart.DataSeries.Clear();
dsFactor.ChartType = ChartDataSeries.Type.Line;
dsFactor.LineColor = Color.Blue;
dsFactor.ValueAxis = axis;
// Add the data series to the chart
scoreChart.DataSeries.Add(dsFactor);
// Autozoom from 0-15
scoreChart.AutozoomToData(true);
double ratio = (scoreChart.XAxis.MaxOriginFarValue - scoreChart.XAxis.OriginValue) / 15;
scoreChart.XAxis.PixelsPerValue = scoreChart.XAxis.PixelsPerValue * ratio;
ratio = (((factor * 100) + offset) - scoreChart.YAxis.OriginValue) / ((factor * 15) + offset);
scoreChart.YAxis.PixelsPerValue = scoreChart.YAxis.PixelsPerValue * ratio;
}
/// <summary>
/// Signals to the Chart that a Series no longer needs to use the axis
/// within this series host.
/// </summary>
/// <param name="series">The Series object that no longer needs to use
/// the axis.</param>
/// <param name="axis">The axis that the Series no longer needs to use.
/// </param>
void ISeriesHost.UnregisterWithAxis(Series series, IAxis axis)
{
if (series == null)
{
throw new ArgumentNullException("series");
}
if (axis == null)
{
throw new ArgumentNullException("axis");
}
if (!ActualAxes.Contains(axis))
{
throw new InvalidOperationException(Properties.Resources.Chart_UnregisterWithSeries_OneAxisCannotBeUsedByMultipleCharts);
}
axis.Unregister(series);
// If axis is no longer used and is not in external axes collection
if (!axis.IsUsed && !Axes.Contains(axis))
{
InternalActualAxes.Remove(axis);
}
}
protected override bool HomeProcess(IAxis Axis)
{
bool ret = false;
var phyAxis = Axis as IrixiM12Axis;
// lock the axis
if (phyAxis.Lock())
{
try
{
// start to home
_m12.Home(phyAxis.ID);
Thread.Sleep(500);
phyAxis.ClearRelPosition();
phyAxis.IsHomed = true;
ret = true;
}
catch (Exception ex)
{
phyAxis.LastError = $"{ex.Message}";
ret = false;
}
finally
{
// release the axis
phyAxis.Unlock();
}
}
else
{
phyAxis.LastError = "axis is busy";
ret = false;
}
return(ret);
}
IAxis GetAxis(AxisType type, double binwidth)
{
AxisFactory factory = new AxisFactory();
switch (type)
{
case AxisType.Month:
{
IAxis axis = factory.CreateAxis(AxisType.Month);
axis.SessionColIndex = ColumnCollection.DateIndex;
return(axis);
}
case AxisType.Hour:
{
IAxis axis = factory.CreateAxis(AxisType.Hour);
axis.SessionColIndex = ColumnCollection.DateIndex;
return(axis);
}
case AxisType.WD:
{
IAxis axis = factory.CreateAxis(binwidth);
axis.SessionColIndex = ColumnCollection.WDComp(ColumnCollection.DataSetStart);
return(axis);
}
case AxisType.WS:
{
int i = ColumnCollection.UpperWSComp(ColumnCollection.DataSetStart);
IAxis axis = factory.CreateAxis(binwidth, ColumnCollection.Data.AsDataView(), i);
axis.SessionColIndex = i;
return(axis);
}
default:
return(null);
}
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
double dependentValueMargin = this.ActualHeight / 10;
IAxis axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func <DataPoint, IComparable> selector = null;
if (axis == InternalActualIndependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualIndependentValue;
DataPoint minimumPoint = ActiveDataPoints.MinOrNull(selector);
DataPoint maximumPoint = ActiveDataPoints.MaxOrNull(selector);
double minimumMargin = minimumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(minimumPoint), minimumMargin, minimumMargin));
double maximumMargin = maximumPoint.GetMargin(axis);
yield return(new ValueMargin(selector(maximumPoint), maximumMargin, maximumMargin));
}
else if (axis == InternalActualDependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualDependentValue;
DataPoint minimumPoint = ActiveDataPoints.MinOrNull(selector);
DataPoint maximumPoint = ActiveDataPoints.MaxOrNull(selector);
yield return(new ValueMargin(selector(minimumPoint), dependentValueMargin, dependentValueMargin));
yield return(new ValueMargin(selector(maximumPoint), dependentValueMargin, dependentValueMargin));
}
}
else
{
yield break;
}
}
private void LocateVertex(IAxis axis, Vertex3D vertex,
params double[] additionalOffset)
{
var coordinates = vertex.Position.CoordinatesValues.ToArray();
var vertexOffset = new Offset
{
CoordinateValue = coordinates[axis.IndexNumber],
DistanceBetweenVertices = DistancesBetween[axis.IndexNumber],
AdditionalOffset = additionalOffset.ElementAtOrDefault(axis.IndexNumber),
VertexSize = vertex.Size
};
double offset = vertexOffset.VertexOffset;
if (!(vertex.Transform is TranslateTransform3D transform))
{
string paramName = nameof(vertex.Transform);
string requiredType = nameof(TranslateTransform3D);
string message = $"{paramName} is not of type {requiredType}";
throw new Exception(message);
}
axis.Offset(transform, offset);
}
/// <inheritdoc/>
public virtual DimensinalBounds GetBounds(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> x, IAxis <TDrawingContext> y)
{
var stack = chart.SeriesContext.GetStackPosition(this, GetStackGroup());
var bounds = new DimensinalBounds();
foreach (var point in Fetch(chart))
{
var secondary = point.SecondaryValue;
var primary = point.PrimaryValue;
if (stack != null)
{
primary = stack.StackPoint(point);
}
bounds.PrimaryBounds.AppendValue(primary);
bounds.SecondaryBounds.AppendValue(secondary);
}
return(bounds);
}
public override void EnsureAxes(Collection <IAxis> axes, IAxis defaultXAxis, IAxis defaultYAxis)
{
if (this.XAxisKey != null)
{
this.XAxis = axes.FirstOrDefault(a => a.Key == this.XAxisKey);
}
if (this.YAxisKey != null)
{
this.YAxis = axes.FirstOrDefault(a => a.Key == this.YAxisKey);
}
// If axes are not found, use the default axes
if (this.XAxis == null)
{
this.XAxis = defaultXAxis;
}
if (this.YAxis == null)
{
this.YAxis = defaultYAxis;
}
}
/// <summary>
/// Gets the bounds.
/// </summary>
/// <param name="chart">The chart.</param>
/// <param name="secondaryAxis">The secondary axis.</param>
/// <param name="primaryAxis">The primary axis.</param>
/// <returns></returns>
public override DimensionalBounds GetBounds(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> secondaryAxis, IAxis <TDrawingContext> primaryAxis)
{
var baseBounds = base.GetBounds(chart, secondaryAxis, primaryAxis);
var tickPrimary = primaryAxis.GetTick(chart.ControlSize, baseBounds.VisiblePrimaryBounds);
var tickSecondary = secondaryAxis.GetTick(chart.ControlSize, baseBounds.VisibleSecondaryBounds);
var ts = tickSecondary.Value * DataPadding.X;
var tp = tickPrimary.Value * DataPadding.Y;
return(new DimensionalBounds
{
SecondaryBounds = new Bounds
{
Max = baseBounds.SecondaryBounds.Max + 0.5 * secondaryAxis.UnitWidth + ts,
Min = baseBounds.SecondaryBounds.Min - 0.5 * secondaryAxis.UnitWidth - ts
},
PrimaryBounds = new Bounds
{
Max = baseBounds.PrimaryBounds.Max + tp,
Min = baseBounds.PrimaryBounds.Min < 0 ? baseBounds.PrimaryBounds.Min - tp : 0
},
VisibleSecondaryBounds = new Bounds
{
Max = baseBounds.VisibleSecondaryBounds.Max + 0.5 * secondaryAxis.UnitWidth + ts,
Min = baseBounds.VisibleSecondaryBounds.Min - 0.5 * secondaryAxis.UnitWidth - ts
},
VisiblePrimaryBounds = new Bounds
{
Max = baseBounds.VisiblePrimaryBounds.Max + tp,
Min = baseBounds.VisiblePrimaryBounds.Min < 0 ? baseBounds.PrimaryBounds.Min - tp : 0
},
MinDeltaPrimary = baseBounds.MinDeltaPrimary,
MinDeltaSecondary = baseBounds.MinDeltaSecondary
});
}
/// <summary>
/// Returns the value margins for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the value margins for.
/// </param>
/// <returns>A sequence of value margins.</returns>
protected virtual IEnumerable <ValueMargin> GetValueMargins(IValueMarginConsumer consumer)
{
IAxis axis = consumer as IAxis;
if (axis != null && ActiveDataPoints.Any())
{
Func <DataPoint, IComparable> selector = null;
DataPoint minimumPoint = null;
DataPoint maximumPoint = null;
double margin = 0.0;
if (axis == InternalActualIndependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualIndependentValue;
minimumPoint = ActiveDataPoints.MinOrNull(selector);
maximumPoint = ActiveDataPoints.MaxOrNull(selector);
margin = minimumPoint.GetActualMargin(this.InternalActualIndependentAxis);
}
else if (axis == InternalActualDependentAxis)
{
selector = (dataPoint) => (IComparable)dataPoint.ActualDependentValue;
Nullable <Tuple <DataPoint, DataPoint> > largestAndSmallestValues = this.DataPointsByActualDependentValue.GetLargestAndSmallestValues();
minimumPoint = largestAndSmallestValues.Value.First;
maximumPoint = largestAndSmallestValues.Value.Second;
margin = minimumPoint.GetActualMargin(this.InternalActualDependentAxis);
}
yield return(new ValueMargin(selector(minimumPoint), margin, margin));
yield return(new ValueMargin(selector(maximumPoint), margin, margin));
}
else
{
yield break;
}
}
public bool Home(IAxis Axis)
{
bool ret = false;
if (!this.IsEnabled) // the controller is configured to be disabled in the config file
{
Axis.LastError = "the controller is disabled";
}
else if (!this.IsInitialized) // the controller is not initialized
{
Axis.LastError = "the controller is not initialized";
}
else if (!Axis.IsEnabled) // the axis moved is disabled in the config file
{
Axis.LastError = "the axis is disabled";
}
else
{
if (BusyAxesCount <= 0)
{
OnMoveBegin?.Invoke(this, new EventArgs());
}
IncreaceBusyAxesCount();
ret = CustomHomeProcess(Axis);
DecreaceBusyAxesCount();
if (BusyAxesCount <= 0)
{
OnMoveEnd?.Invoke(this, new EventArgs());
}
}
return(ret);
}
/// <inheritdoc/>
public virtual DimensinalBounds GetBounds(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> x, IAxis <TDrawingContext> y)
{
var stack = chart.SeriesContext.GetStackPosition(this, GetStackGroup());
var bounds = new DimensinalBounds();
foreach (var point in Fetch(chart))
{
var primary = point.PrimaryValue;
var secondary = point.SecondaryValue;
// it has more sense to override this method and call the stack, only if the series requires so.
if (stack != null)
{
primary = stack.StackPoint(point);
}
bounds.PrimaryBounds.AppendValue(primary);
bounds.SecondaryBounds.AppendValue(secondary);
}
return(bounds);
}
/// <summary>
/// Acquire a horizontal linear axis and a vertical linear axis.
/// </summary>
/// <param name="firstPoint">The first point.</param>
protected override void GetAxes(ChartPoint <TIndependent, TDependent> firstPoint)
{
this.GetAxes(
firstPoint,
axis => axis.Orientation == AxisOrientation.X,
() =>
{
IAxis axis = CreateRangeAxisFromType(typeof(TIndependent)) ?? (IAxis) new CategoryAxis();
axis.Orientation = AxisOrientation.X;
return(axis);
},
axis => axis.Orientation == AxisOrientation.Y && axis is IRangeAxis,
() =>
{
DisplayAxis axis = (DisplayAxis)CreateRangeAxisFromType(typeof(TDependent));
if (axis == null)
{
throw new InvalidOperationException("No suitable axis found");
}
axis.ShowGridLines = true;
axis.Orientation = AxisOrientation.Y;
return(axis);
});
}
public IRestResource GetChild(string startResourceName)
{
IRootStartInfo startInfo = _startInfoFactory.Get(_configuration, startResourceName);
Type stemType = startInfo.GetStemType();
if (stemType == null)
{
throw new ArgumentNullException(nameof(stemType), "Root class StartStemType cannot be null.");
}
IAxis axis = startInfo.GetAxis(_configuration, _request.User);
_request.OnDispose += delegate { axis.Dispose(); };
var autoActivator = new AutoActivator(_configuration.DependencyResolver);
var stem = (Stem)autoActivator.CreateInstance(stemType);
stem.SetParent(axis);
IDataSourceCollectionCreator creator = _creatorCache.GetOrAdd(startResourceName, delegate
{
Type stemGenericBaseType = stemType.GetGenericSubclass(typeof(Stem <>));
if (stemGenericBaseType == null)
{
throw new StemStartSetupException("The Stem class does not derive from Stem<>.");
}
Type itemType = stemGenericBaseType.GenericTypeArguments[0];
Type creatorType = typeof(DataSourceCollectionCreator <>).MakeGenericType(itemType);
IDataSource dataSource = startInfo.GetDataSource(); // TODO same instance from first root reused?
return((IDataSourceCollectionCreator)Activator.CreateInstance(creatorType, dataSource));
});
return(creator.GetRestCollection(stem));
}
/// <summary>
/// Notifies the specified axis of changes to values plotting against it.
/// </summary>
/// <param name="axis">Specified axis.</param>
protected void NotifyAxisValuesChanged(IAxis axis)
{
if (null != axis)
{
IRangeConsumer rangeConsumer = axis as IRangeConsumer;
if (null != rangeConsumer)
{
IRangeProvider rangeProvider = (IRangeProvider)this;
rangeConsumer.RangeChanged(rangeProvider, new Range<IComparable>() /*rangeProvider.GetRange(rangeConsumer)*/);
}
IDataConsumer dataConsumer = axis as IDataConsumer;
if (null != dataConsumer)
{
IDataProvider dataProvider = (IDataProvider)this;
dataConsumer.DataChanged(dataProvider, null /*dataProvider.GetData(dataConsumer)*/);
}
}
}
private void OnIndependentAxisChanged(IAxis oldValue, IAxis newValue)
{
if (null != ActualIndependentAxis)
{
EnsureAxes(false, true, false);
}
}
/// <summary>
/// Handles notification of the invalidation of an axis.
/// </summary>
/// <param name="axis">Invalidated axis.</param>
void IAxisListener.AxisInvalidated(IAxis axis)
{
QueueUpdateDataItemPlacement(false, false, DataItems);
}
/// <summary>
/// IndependentAxisProperty property changed handler.
/// </summary>
/// <param name="newValue">New value.</param>
private void OnIndependentAxisPropertyChanged(IAxis newValue)
{
this.InternalIndependentAxis = (IAxis)newValue;
}
public override void Measure(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> secondaryAxis, IAxis <TDrawingContext> primaryAxis)
{
var drawLocation = chart.DrawMaringLocation;
var drawMarginSize = chart.DrawMarginSize;
var secondaryScale = new ScaleContext(drawLocation, drawMarginSize, primaryAxis.Orientation, primaryAxis.DataBounds);
var primaryScale = new ScaleContext(drawLocation, drawMarginSize, secondaryAxis.Orientation, secondaryAxis.DataBounds);
float uw = secondaryScale.ScaleToUi(1f) - secondaryScale.ScaleToUi(0f);
float uwm = 0.5f * uw;
float sw = Stroke?.StrokeWidth ?? 0;
float p = primaryScale.ScaleToUi(pivot);
var pos = chart.SeriesContext.GetStackedColumnPostion(this);
var count = chart.SeriesContext.GetStackedColumnSeriesCount();
float cp = 0f;
if (count > 1)
{
uw = uw / count;
uwm = 0.5f * uw;
cp = (pos - (count / 2f)) * uw + uwm;
}
if (uw > MaxColumnWidth)
{
uw = unchecked ((float)MaxColumnWidth);
uwm = uw / 2f;
}
if (Fill != null)
{
chart.Canvas.AddDrawableTask(Fill);
}
if (Stroke != null)
{
chart.Canvas.AddDrawableTask(Stroke);
}
if (DataLabelsBrush != null)
{
chart.Canvas.AddDrawableTask(DataLabelsBrush);
}
var dls = unchecked ((float)DataLabelsSize);
var chartAnimation = new Animation(chart.EasingFunction, chart.AnimationsSpeed);
var ts = OnPointCreated ?? DefaultOnPointCreated;
var stacker = chart.SeriesContext.GetStackPosition(this, GetStackGroup());
if (stacker == null)
{
throw new NullReferenceException("Unexpected null stacker");
}
foreach (var point in Fetch(chart))
{
var secondary = secondaryScale.ScaleToUi(point.SecondaryValue);
if (point.IsNull)
{
if (point.Context.Visual != null)
{
point.Context.Visual.X = p;
point.Context.Visual.Y = secondary - uwm + cp;
point.Context.Visual.Width = 0;
point.Context.Visual.Height = uw;
point.Context.Visual.RemoveOnCompleted = true;
point.Context.Visual = null;
}
continue;
}
if (point.Context.Visual == null)
{
var r = new TVisual
{
X = p,
Y = secondary - uwm + cp,
Width = 0,
Height = uw
};
ts(r, chart.View);
r.CompleteAllTransitions();
point.Context.Visual = r;
if (Fill != null)
{
Fill.AddGeometyToPaintTask(r);
}
if (Stroke != null)
{
Stroke.AddGeometyToPaintTask(r);
}
}
var sizedGeometry = point.Context.Visual;
var sy = stacker.GetStack(point);
var primaryI = primaryScale.ScaleToUi(sy.Start);
var primaryJ = primaryScale.ScaleToUi(sy.End);
var y = secondary - uwm + cp;
sizedGeometry.X = primaryJ;
sizedGeometry.Y = y;
sizedGeometry.Width = primaryI - primaryJ;
sizedGeometry.Height = uw;
sizedGeometry.RemoveOnCompleted = false;
point.Context.HoverArea = new RectangleHoverArea().SetDimensions(secondary - uwm + cp, primaryJ, uw, primaryI - primaryJ);
OnPointMeasured(point, sizedGeometry);
chart.MeasuredDrawables.Add(sizedGeometry);
if (DataLabelsBrush != null)
{
if (point.Context.Label == null)
{
var l = new TLabel {
X = secondary - uwm + cp, Y = p
};
l.TransitionateProperties(nameof(l.X), nameof(l.Y))
.WithAnimation(a =>
a.WithDuration(chart.AnimationsSpeed)
.WithEasingFunction(chart.EasingFunction));
l.CompleteAllTransitions();
point.Context.Label = l;
DataLabelsBrush.AddGeometyToPaintTask(l);
}
point.Context.Label.Text = DataLabelFormatter(point);
point.Context.Label.TextSize = dls;
point.Context.Label.Padding = DataLabelsPadding;
var labelPosition = GetLabelPosition(
primaryJ, y, primaryI - primaryJ, uw, point.Context.Label.Measure(DataLabelsBrush), DataLabelsPosition, SeriesProperties, point.PrimaryValue > Pivot);
point.Context.Label.X = labelPosition.X;
point.Context.Label.Y = labelPosition.Y;
chart.MeasuredDrawables.Add(point.Context.Label);
}
}
}
public override bool IsUsing(IAxis axis)
{
return this.XAxis == axis || this.YAxis == axis;
}
private void UpdateVerticalTicks(IAxis axis)
{
if (axis != null)
{
axisGrid.VerticalTicks = axis.ScreenTicks;
}
else
{
axisGrid.VerticalTicks = null;
}
}
public override void SwapAxes(IAxis source, IAxis target)
{
// Swap points in line segments
IList <ChartLineSegment> sourceXLineSegments = new List <ChartLineSegment>();
IList <ChartLineSegment> sourceYLineSegments = new List <ChartLineSegment>();
IList <ChartLineSegment> targetXLineSegments = new List <ChartLineSegment>();
IList <ChartLineSegment> targetYLineSegments = new List <ChartLineSegment>();
foreach (var chartPoint in source.Points)
{
foreach (var line in source.Chart.Lines)
{
foreach (var segment in line.Segments)
{
if (segment.PointX == chartPoint)
{
sourceXLineSegments.Add(segment);
}
if (segment.PointY == chartPoint)
{
sourceYLineSegments.Add(segment);
}
}
}
}
foreach (var chartPoint in target.Points)
{
foreach (var line in target.Chart.Lines)
{
foreach (var segment in line.Segments)
{
if (segment.PointX == chartPoint)
{
targetXLineSegments.Add(segment);
}
if (segment.PointY == chartPoint)
{
targetYLineSegments.Add(segment);
}
}
}
}
for (int i = 0; i < target.Points.Count; i++)
{
if (sourceXLineSegments.Count > 0)
{
sourceXLineSegments[i].PointX = target.Points[i];
}
if (sourceYLineSegments.Count > 0)
{
sourceYLineSegments[i].PointY = target.Points[i];
}
if (targetXLineSegments.Count > 0)
{
targetXLineSegments[i].PointX = source.Points[i];
}
if (targetYLineSegments.Count > 0)
{
targetYLineSegments[i].PointY = source.Points[i];
}
}
double originalValue = source.OriginalValue;
source.OriginalValue = target.OriginalValue;
target.OriginalValue = originalValue;
var helperAxis = target.Chart.Axes[target.Chart.Axes.Count - 1];
helperAxis.Transformation.Transform(helperAxis, helperAxis.DependentAxes);
}
/// <summary>
/// IndependentAxisProperty property changed handler.
/// </summary>
/// <param name="oldValue">Old value.</param>
/// <param name="newValue">New value.</param>
protected virtual void OnInternalIndependentAxisPropertyChanged(IAxis oldValue, IAxis newValue)
{
if (newValue != null &&
InternalActualIndependentAxis != null &&
InternalActualIndependentAxis != newValue &&
InternalActualIndependentAxis.RegisteredListeners.Contains(this))
{
InternalActualIndependentAxis.RegisteredListeners.Remove(this);
InternalActualIndependentAxis = null;
GetAxes();
}
}
public override void Scale(IAxis axis, int delta)
{
axis.Scale *= 1.0 + delta / 2000.0;
}
public override void FitToView(IChart chart, IAxis axis, double width, double height)
{
if (axis.Orientation == AxisOrientation.Vertical)
{
const double margin = 50;
double min = double.MaxValue, max = double.MinValue;
foreach (var chartPoint in chart.Points)
{
if (chartPoint.Axes.Contains(axis))
{
if (chartPoint.Data[axis.Dimension] > max)
{
max = chartPoint.Data[axis.Dimension];
}
if (chartPoint.Data[axis.Dimension] < min)
{
min = chartPoint.Data[axis.Dimension];
}
}
}
double heightWithMargin = height - margin;
double scale = 1.0;
double translate;
if (min != max)
{
scale = heightWithMargin / (max - min);
translate = (heightWithMargin) / 2 + min * scale;
}
else
{
translate = min * scale;
}
axis.Scale = -scale;
axis.Translate = translate;
Transform(axis, axis.Points);
}
else if (axis.Orientation == AxisOrientation.Horizontal)
{
const double margin = 50;
double min = double.MaxValue, max = double.MinValue;
foreach (var dependentAxis in axis.DependentAxes)
{
if (dependentAxis.OriginalValue > max)
{
max = dependentAxis.OriginalValue;
}
if (dependentAxis.OriginalValue < min)
{
min = dependentAxis.OriginalValue;
}
}
double widthWithMargin = width - margin;
double scale = 1.0;
double translate = margin / 2;
if (min != max)
{
scale = widthWithMargin / (max - min);
}
axis.Scale = scale;
axis.Translate = translate;
foreach (var dependentAxis in axis.DependentAxes)
{
Transform(axis, dependentAxis);
}
}
}
public override void EnsureAxes(Collection<IAxis> axes, IAxis defaultXAxis, IAxis defaultYAxis)
{
if (this.XAxisKey != null)
{
this.XAxis = axes.FirstOrDefault(a => a.Key == this.XAxisKey);
}
if (this.YAxisKey != null)
{
this.YAxis = axes.FirstOrDefault(a => a.Key == this.YAxisKey);
}
// If axes are not found, use the default axes
if (this.XAxis == null)
{
this.XAxis = defaultXAxis;
}
if (this.YAxis == null)
{
this.YAxis = defaultYAxis;
}
}
/// <summary>
/// Notifies the specified axis of changes to value margins plotting against it.
/// </summary>
/// <param name="axis">Specified axis.</param>
/// <param name="valueMargins">Sequence of value margins that have changed.</param>
protected void NotifyValueMarginsChanged(IAxis axis, IEnumerable<ValueMargin> valueMargins)
{
if (null != axis)
{
IValueMarginConsumer valueMarginConsumer = axis as IValueMarginConsumer;
if (null != valueMarginConsumer)
{
IValueMarginProvider valueMarginProvider = (IValueMarginProvider)this;
valueMarginConsumer.ValueMarginsChanged(valueMarginProvider, valueMargins);
}
}
}
/// <summary>
/// Measures this series.
/// </summary>
/// <param name="chart">The chart.</param>
/// <param name="secondaryAxis">The secondary axis.</param>
/// <param name="primaryAxis">The primary axis.</param>
/// <exception cref="NullReferenceException">Unexpected null stacker</exception>
public override void Measure(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> secondaryAxis, IAxis <TDrawingContext> primaryAxis)
{
var drawLocation = chart.DrawMarginLocation;
var drawMarginSize = chart.DrawMarginSize;
var secondaryScale = new Scaler(drawLocation, drawMarginSize, primaryAxis);
var previousSecondaryScale =
primaryAxis.PreviousDataBounds == null ? null : new Scaler(drawLocation, drawMarginSize, primaryAxis);
var primaryScale = new Scaler(drawLocation, drawMarginSize, secondaryAxis);
var uw = secondaryScale.ToPixels(1f) - secondaryScale.ToPixels(0f);
var uwm = 0.5f * uw;
var sw = Stroke?.StrokeThickness ?? 0;
var p = primaryScale.ToPixels(pivot);
var pos = chart.SeriesContext.GetStackedColumnPostion(this);
var count = chart.SeriesContext.GetStackedColumnSeriesCount();
var cp = 0f;
if (count > 1)
{
uw /= count;
uwm = 0.5f * uw;
cp = (pos - count / 2f) * uw + uwm;
}
if (uw > MaxBarWidth)
{
uw = (float)MaxBarWidth;
uwm = uw / 2f;
}
var actualZIndex = ZIndex == 0 ? ((ISeries)this).SeriesId : ZIndex;
if (Fill != null)
{
Fill.ZIndex = actualZIndex + 0.1;
Fill.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(Fill);
}
if (Stroke != null)
{
Stroke.ZIndex = actualZIndex + 0.2;
Stroke.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(Stroke);
}
if (DataLabelsDrawableTask != null)
{
DataLabelsDrawableTask.ZIndex = actualZIndex + 0.3;
DataLabelsDrawableTask.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(DataLabelsDrawableTask);
}
var dls = (float)DataLabelsSize;
var toDeletePoints = new HashSet <ChartPoint>(everFetched);
var stacker = chart.SeriesContext.GetStackPosition(this, GetStackGroup());
if (stacker == null)
{
throw new NullReferenceException("Unexpected null stacker");
}
var rx = (float)Rx;
var ry = (float)Ry;
foreach (var point in Fetch(chart))
{
var visual = point.Context.Visual as TVisual;
var secondary = secondaryScale.ToPixels(point.SecondaryValue);
if (point.IsNull)
{
if (visual != null)
{
visual.X = p;
visual.Y = secondary - uwm + cp;
visual.Width = 0;
visual.Height = uw;
visual.RemoveOnCompleted = true;
point.Context.Visual = null;
}
continue;
}
if (visual == null)
{
var yi = secondary - uwm + cp;
if (previousSecondaryScale != null)
{
yi = previousSecondaryScale.ToPixels(point.SecondaryValue) - uwm + cp;
}
var r = new TVisual
{
X = p,
Y = yi,
Width = 0,
Height = uw,
Rx = rx,
Ry = ry
};
visual = r;
point.Context.Visual = visual;
OnPointCreated(point);
r.CompleteAllTransitions();
_ = everFetched.Add(point);
}
if (Fill != null)
{
Fill.AddGeometryToPaintTask(visual);
}
if (Stroke != null)
{
Stroke.AddGeometryToPaintTask(visual);
}
var sizedGeometry = visual;
var sy = stacker.GetStack(point);
var primaryI = primaryScale.ToPixels(sy.Start);
var primaryJ = primaryScale.ToPixels(sy.End);
var y = secondary - uwm + cp;
sizedGeometry.X = primaryJ;
sizedGeometry.Y = y;
sizedGeometry.Width = primaryI - primaryJ;
sizedGeometry.Height = uw;
sizedGeometry.Rx = rx;
sizedGeometry.Ry = ry;
sizedGeometry.RemoveOnCompleted = false;
point.Context.HoverArea = new RectangleHoverArea().SetDimensions(secondary - uwm + cp, primaryJ, uw, primaryI - primaryJ);
OnPointMeasured(point);
_ = toDeletePoints.Remove(point);
if (DataLabelsDrawableTask != null)
{
var label = (TLabel?)point.Context.Label;
if (label == null)
{
var l = new TLabel {
X = secondary - uwm + cp, Y = p
};
_ = l.TransitionateProperties(nameof(l.X), nameof(l.Y))
.WithAnimation(animation =>
animation
.WithDuration(AnimationsSpeed ?? chart.AnimationsSpeed)
.WithEasingFunction(EasingFunction ?? chart.EasingFunction));
l.CompleteAllTransitions();
label = l;
point.Context.Label = label;
}
DataLabelsDrawableTask.AddGeometryToPaintTask(label);
label.Text = DataLabelsFormatter(point);
label.TextSize = dls;
label.Padding = DataLabelsPadding;
var labelPosition = GetLabelPosition(
primaryJ, y, primaryI - primaryJ, uw, label.Measure(DataLabelsDrawableTask), DataLabelsPosition, SeriesProperties, point.PrimaryValue > Pivot);
label.X = labelPosition.X;
label.Y = labelPosition.Y;
}
}
foreach (var point in toDeletePoints)
{
if (point.Context.Chart != chart.View)
{
continue;
}
SoftDeletePoint(point, primaryScale, secondaryScale);
_ = everFetched.Remove(point);
}
}
/// <summary>
/// Gets the margin to use for an independent axis that does not implement ICategoryAxis.
/// </summary>
/// <param name="axis">Axis to get the margin for.</param>
/// <returns>Margin for axis.</returns>
private double GetMarginForNonCategoryAxis(IAxis axis)
{
Debug.Assert(!(axis is ICategoryAxis), "This method is unnecessary for ICategoryAxis.");
// Find the smallest distance between two independent value plot area coordinates
double smallestDistance = double.MaxValue;
double lastCoordinate = double.NaN;
foreach (double coordinate in
IndependentValueGroupsOrderedByIndependentValue
.Select(g => axis.GetPlotAreaCoordinate(g.IndependentValue).Value)
.Where(v => ValueHelper.CanGraph(v)))
{
if (!double.IsNaN(lastCoordinate))
{
double distance = coordinate - lastCoordinate;
if (distance < smallestDistance)
{
smallestDistance = distance;
}
}
lastCoordinate = coordinate;
}
// Return the margin
if (double.MaxValue == smallestDistance)
{
// No smallest distance because <= 1 independent values to plot
FrameworkElement element = axis as FrameworkElement;
if (null != element)
{
// Use width of provided axis so single column scenario looks good
return element.GetMargin(axis);
}
else
{
// No information to work with; no idea what margin to return
throw new NotSupportedException();
}
}
else
{
// Found the smallest distance; margin is half of that
return smallestDistance / 2;
}
}
protected void UpdateHorizontalTicks(IAxis axis)
{
if (axis != null)
{
axisGrid.HorizontalTicks = axis.ScreenTicks;
}
else
{
axisGrid.HorizontalTicks = null;
}
}
/// <summary>
/// Updates the series when the axis is invalidated.
/// </summary>
/// <param name="axis">The axis that was invalidated.</param>
public void AxisInvalidated(IAxis axis)
{
if (DependentAxis != null && IndependentAxis != null)
{
Refresh();
}
}
public void AddAxis(IAxis axis)
{
mAxisConfig.ConfigureAxis(axis, mOverlayPlugin.Core);
mAxes.Add(axis);
if (AxisAdded != null)
AxisAdded(axis);
}
public override void Transform(IAxis axis, IAxis dependentAxis)
{
dependentAxis.Value = dependentAxis.OriginalValue * axis.Scale + axis.Translate;
Transform(dependentAxis, dependentAxis.Points);
}
public void AddAxis(IAxis axis)
{
// �X���b�h�Z�[�t�ɂ��邽�߃��b�N�������
lock (_axes)
{
// ���X�g�ɉ����A
_axes.Add(axis);
}
// �����Ƃ��A�e�g�̍�����v�Z����
SetAxes();
}
public override void Translate(IAxis axis, double change)
{
axis.Translate = change;
}
/// <summary>
/// Redraws grid lines when the axis is invalidated.
/// </summary>
/// <param name="axis">The invalidated axis.</param>
public void AxisInvalidated(IAxis axis)
{
Invalidate();
}
void RunShear()
{
BackgroundWorker worker = new BackgroundWorker();
try
{
worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e)
{
};
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
try
{
IsProcessing = true;
int upperCompidx = ColumnCollection.UpperWSComp(DataSetStartDate);
int lowerCompidx = ColumnCollection.LowerWSComp(DataSetStartDate);
ISessionColumn upperws = ColumnCollection[upperCompidx];
ISessionColumn lowerws = ColumnCollection[lowerCompidx];
IAxis Xaxis = GetAxis(_xShearAxis, _xBinWidth);
IAxis Yaxis = GetAxis(_yShearAxis, _yBinWidth);
AlphaFactory afactory = new AlphaFactory();
Alpha alpha = (Alpha)afactory.CreateAlpha(DownloadedData[0], _alphaFilter, upperws, lowerws, Xaxis, Yaxis);
alpha.AlphaUpdated += new Alpha.AlphaUpdatedEventHandler(UpdatedAlphaCollection);
alpha.SourceDataSet = this.DisplayName;
ColumnCollection.AlphaCollection.Add(alpha);
alpha.CalculateAlpha();
string xBin = string.Empty;
string yBin = string.Empty;
if (Xaxis.AxisType == AxisType.WD)
{
var wdaxis = (WindDirectionAxis)Xaxis;
xBin = " " + wdaxis.BinWidth.ToString() + " deg";
}
if (Xaxis.AxisType == AxisType.WS)
{
var wsaxis = (WindSpeedAxis)Xaxis;
xBin = " " + wsaxis.BinWidth.ToString() + " m/s";
}
if (Yaxis.AxisType == AxisType.WD)
{
var wdaxis = (WindDirectionAxis)Yaxis;
yBin = " " + wdaxis.BinWidth.ToString() + " deg";
}
if (Yaxis.AxisType == AxisType.WS)
{
var wsaxis = (WindSpeedAxis)Yaxis;
yBin = " " + wsaxis.BinWidth.ToString() + " m/s";
}
AllShearViewModel asvm = new AllShearViewModel();
string filter;
if (_alphaFilter == AlphaFilterMethod.Coincident)
{
filter = "CDNT";
}
else
{
filter = "NCDNT";
}
string gridname = alpha.SourceDataSet + "_" + filter + "_" + Xaxis.AxisType + xBin + " by " + Yaxis.AxisType + yBin;
ShearGridViewModel sgvm = new ShearGridViewModel(alpha, gridname);
if (ShearGridCollection == null)
{
ShearGridCollection = new AllShearViewModel();
}
if (ShearGridCollection.ShearCollection.Count == 0)
{
asvm.ShearCollection.Add(sgvm);
}
UpdatedAlphaCollection(alpha);
alpha.AlphaUpdated -= UpdatedAlphaCollection;
this.Dispatcher.Invoke(DispatcherPriority.Render, new Action
(
delegate()
{
if (ShearGridCollection.ShearCollection.Count == 0)
{
ShearGridCollection = asvm;
}
else
{
ShearGridCollection.ShearCollection.Add(sgvm);
}
}));
//add sheargridviewmodels to allsheargridviewmodel
IsProcessing = false;
}
catch (ApplicationException e)
{
MessageBox.Show(e.Message);
}
finally
{
IsProcessing = false;
}
};
worker.RunWorkerAsync();
}
catch (Exception e)
{
throw;
}
}
protected virtual void ValidateVerticalAxis(IAxis axis)
{
}
/// <summary>
/// Method called to get the axes that the series needs.
/// </summary>
/// <param name="firstDataPoint">The first data point.</param>
/// <param name="independentAxisPredicate">A predicate that returns
/// a value indicating whether an axis is an acceptable candidate for
/// the series independent axis.</param>
/// <param name="independentAxisFactory">A function that creates an
/// acceptable independent axis.</param>
/// <param name="dependentAxisPredicate">A predicate that returns
/// a value indicating whether an axis is an acceptable candidate for
/// the series dependent axis.</param>
/// <param name="dependentAxisFactory">A function that creates an
/// acceptable dependent axis.</param>
protected virtual void GetAxes(DataPoint firstDataPoint, Func <IAxis, bool> independentAxisPredicate, Func <IAxis> independentAxisFactory, Func <IAxis, bool> dependentAxisPredicate, Func <IAxis> dependentAxisFactory)
{
Func <IAxis, bool> actualIndependentAxisPredicate = (axis) => independentAxisPredicate(axis) && axis.CanPlot(firstDataPoint.IndependentValue);
IAxis workingIndependentAxis = null;
if (this.InternalActualIndependentAxis == null)
{
if (this.InternalIndependentAxis != null)
{
if (actualIndependentAxisPredicate(this.InternalIndependentAxis))
{
workingIndependentAxis = this.InternalIndependentAxis;
}
else
{
throw new InvalidOperationException(Properties.Resources.DataPointSeriesWithAxes_GetAxes_AssignedIndependentAxisCannotBeUsed);
}
}
if (workingIndependentAxis == null)
{
workingIndependentAxis = this.SeriesHost.Axes.FirstOrDefault(actualIndependentAxisPredicate);
}
if (workingIndependentAxis == null)
{
workingIndependentAxis = independentAxisFactory();
}
this.InternalActualIndependentAxis = workingIndependentAxis;
if (!workingIndependentAxis.RegisteredListeners.Contains(this))
{
workingIndependentAxis.RegisteredListeners.Add(this);
}
if (!this.SeriesHost.Axes.Contains(workingIndependentAxis))
{
this.SeriesHost.Axes.Add(workingIndependentAxis);
}
}
Func <IAxis, bool> actualDependentAxisPredicate = (axis) => dependentAxisPredicate(axis) && axis.CanPlot(firstDataPoint.DependentValue);
IAxis workingDependentAxis = null;
if (this.InternalActualDependentAxis == null)
{
if (this.InternalDependentAxis != null)
{
if (actualDependentAxisPredicate(this.InternalDependentAxis))
{
workingDependentAxis = this.InternalDependentAxis;
}
else
{
throw new InvalidOperationException(Properties.Resources.DataPointSeriesWithAxes_GetAxes_AssignedDependentAxisCannotBeUsed);
}
}
if (workingDependentAxis == null)
{
workingDependentAxis = InternalActualIndependentAxis.DependentAxes.Concat(this.SeriesHost.Axes).FirstOrDefault(actualDependentAxisPredicate);
}
if (workingDependentAxis == null)
{
workingDependentAxis = dependentAxisFactory();
}
this.InternalActualDependentAxis = workingDependentAxis;
if (!workingDependentAxis.RegisteredListeners.Contains(this))
{
workingDependentAxis.RegisteredListeners.Add(this);
}
// Only add axis to the axes collection of the series host if
// it is not a dependent axis belonging to the acquired
// independent axis.
if (!this.SeriesHost.Axes.Contains(workingDependentAxis) && !InternalActualIndependentAxis.DependentAxes.Contains(workingDependentAxis))
{
this.SeriesHost.Axes.Add(workingDependentAxis);
}
}
}
protected virtual void ValidateHorizontalAxis(IAxis axis)
{
}
/// <inheritdoc cref="ICartesianSeries{TDrawingContext}.Measure(CartesianChart{TDrawingContext}, IAxis{TDrawingContext}, IAxis{TDrawingContext})"/>
public override void Measure(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> secondaryAxis, IAxis <TDrawingContext> primaryAxis)
{
var drawLocation = chart.DrawMarginLocation;
var drawMarginSize = chart.DrawMarginSize;
var secondaryScale = new Scaler(drawLocation, drawMarginSize, secondaryAxis);
var primaryScale = new Scaler(drawLocation, drawMarginSize, primaryAxis);
var previousPrimaryScale =
primaryAxis.PreviousDataBounds == null ? null : new Scaler(drawLocation, drawMarginSize, primaryAxis, true);
var previousSecondaryScale =
secondaryAxis.PreviousDataBounds == null ? null : new Scaler(drawLocation, drawMarginSize, secondaryAxis, true);
var uw = secondaryScale.ToPixels((float)secondaryAxis.UnitWidth) - secondaryScale.ToPixels(0f);
var puw = previousSecondaryScale == null ? 0 : previousSecondaryScale.ToPixels((float)secondaryAxis.UnitWidth) - previousSecondaryScale.ToPixels(0f);
uw -= (float)GroupPadding;
puw -= (float)GroupPadding;
var uwm = 0.5f * uw;
var pos = chart.SeriesContext.GetColumnPostion(this);
var count = chart.SeriesContext.GetColumnSeriesCount();
var cp = 0f;
if (!IgnoresBarPosition && count > 1)
{
uw /= count;
puw /= count;
uwm = 0.5f * uw;
cp = (pos - count / 2f) * uw + uwm;
}
if (uw > MaxBarWidth)
{
uw = (float)MaxBarWidth;
uwm = uw * 0.5f;
puw = uw;
}
var sw = Stroke?.StrokeThickness ?? 0;
var p = primaryScale.ToPixels(pivot);
var actualZIndex = ZIndex == 0 ? ((ISeries)this).SeriesId : ZIndex;
if (Fill != null)
{
Fill.ZIndex = actualZIndex + 0.1;
Fill.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(Fill);
}
if (Stroke != null)
{
Stroke.ZIndex = actualZIndex + 0.2;
Stroke.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(Stroke);
}
if (DataLabelsDrawableTask != null)
{
DataLabelsDrawableTask.ZIndex = actualZIndex + 0.3;
DataLabelsDrawableTask.ClipRectangle = new RectangleF(drawLocation, drawMarginSize);
chart.Canvas.AddDrawableTask(DataLabelsDrawableTask);
}
var dls = (float)DataLabelsSize;
var toDeletePoints = new HashSet <ChartPoint>(everFetched);
var rx = (float)Rx;
var ry = (float)Ry;
foreach (var point in Fetch(chart))
{
var visual = point.Context.Visual as TVisual;
var primary = primaryScale.ToPixels(point.PrimaryValue);
var secondary = secondaryScale.ToPixels(point.SecondaryValue);
var b = Math.Abs(primary - p);
if (point.IsNull)
{
if (visual != null)
{
visual.X = secondary - uwm + cp;
visual.Y = p;
visual.Width = uw;
visual.Height = 0;
visual.RemoveOnCompleted = true;
point.Context.Visual = null;
}
continue;
}
if (visual == null)
{
var xi = secondary - uwm + cp;
var pi = p;
var uwi = uw;
var hi = 0f;
if (previousSecondaryScale != null && previousPrimaryScale != null)
{
var previousP = previousPrimaryScale.ToPixels(pivot);
var previousPrimary = previousPrimaryScale.ToPixels(point.PrimaryValue);
var bp = Math.Abs(previousPrimary - previousP);
var cyp = point.PrimaryValue > pivot ? previousPrimary : previousPrimary - bp;
xi = previousSecondaryScale.ToPixels(point.SecondaryValue) - uwm + cp;
pi = chart.IsZoomingOrPanning ? cyp : previousP;
uwi = puw;
hi = chart.IsZoomingOrPanning ? bp : 0;
}
var r = new TVisual
{
X = xi,
Y = pi,
Width = uwi,
Height = 0,
Rx = rx,
Ry = ry
};
visual = r;
point.Context.Visual = visual;
OnPointCreated(point);
r.CompleteAllTransitions();
_ = everFetched.Add(point);
}
if (Fill != null)
{
Fill.AddGeometryToPaintTask(visual);
}
if (Stroke != null)
{
Stroke.AddGeometryToPaintTask(visual);
}
var cy = point.PrimaryValue > pivot ? primary : primary - b;
var x = secondary - uwm + cp;
visual.X = x;
visual.Y = cy;
visual.Width = uw;
visual.Height = b;
visual.Rx = rx;
visual.Ry = ry;
visual.RemoveOnCompleted = false;
var ha = new RectangleHoverArea().SetDimensions(secondary - uwm + cp, cy, uw, b);
point.Context.HoverArea = ha;
OnPointMeasured(point);
_ = toDeletePoints.Remove(point);
if (DataLabelsDrawableTask != null)
{
var label = (TLabel?)point.Context.Label;
if (label == null)
{
var l = new TLabel {
X = secondary - uwm + cp, Y = p
};
_ = l.TransitionateProperties(nameof(l.X), nameof(l.Y))
.WithAnimation(animation =>
animation
.WithDuration(AnimationsSpeed ?? chart.AnimationsSpeed)
.WithEasingFunction(EasingFunction ?? chart.EasingFunction));
l.CompleteAllTransitions();
label = l;
point.Context.Label = l;
}
DataLabelsDrawableTask.AddGeometryToPaintTask(label);
label.Text = DataLabelsFormatter(point);
label.TextSize = dls;
label.Padding = DataLabelsPadding;
var labelPosition = GetLabelPosition(
x, cy, uw, b, label.Measure(DataLabelsDrawableTask), DataLabelsPosition, SeriesProperties, point.PrimaryValue > Pivot);
label.X = labelPosition.X;
label.Y = labelPosition.Y;
}
}
foreach (var point in toDeletePoints)
{
if (point.Context.Chart != chart.View)
{
continue;
}
SoftDeletePoint(point, primaryScale, secondaryScale);
_ = everFetched.Remove(point);
}
}
void OutPutSummary()
{
BackgroundWorker worker = new BackgroundWorker();
string filename = string.Empty;
SaveFileDialog sf = new SaveFileDialog();
sf.Title = "save data";
sf.Filter = "Excel|*.xlsx";
sf.DefaultExt = ".xlsx";
sf.FileName = "Unified" + "_StnSummary_" + DateTime.Now.ToShortDateString().Replace(@"/", "");
DialogResult result = sf.ShowDialog();
if (result == DialogResult.Cancel)
{
return;
}
if (sf.FileName != "")
{
filename = sf.FileName;
}
else
{
return;
}
worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e)
{
SummaryIsProcessing = false;
};
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
XbyYShearStationSummary summary = null;
try
{
SummaryIsProcessing = true;
//create the DataTable
if (_unifiedData != null)
{
_unifiedData.Clear();
}
BuildDataTable();
//create column collection
ColumnCollection = new SessionColumnCollection(_unifiedData);
//add column def and add configs
ISessionColumn hubws = ColumnCollection[HubHeight.ToString() + "m"];
hubws.ColumnType = SessionColumnType.WSAvgShear;
hubws.IsCalculated = true;
hubws.IsComposite = true;
SensorConfig config = new SensorConfig()
{
StartDate = _startDate, EndDate = _endDate, Height = HubHeight
};
hubws.Configs.Add(config);
ISessionColumn upperws = ColumnCollection[UpperHeight.ToString().Replace(".", "_") + "m"];
upperws.ColumnType = SessionColumnType.WSAvg;
upperws.IsComposite = true;
config = new SensorConfig()
{
StartDate = _startDate, EndDate = _endDate, Height = UpperHeight
};
upperws.Configs.Add(config);
ISessionColumn lowerws = ColumnCollection[LowerHeight.ToString().Replace(".", "_") + "m"];
lowerws.ColumnType = SessionColumnType.WSAvg;
lowerws.IsComposite = true;
config = new SensorConfig()
{
StartDate = _startDate, EndDate = _endDate, Height = LowerHeight
};
lowerws.Configs.Add(config);
ISessionColumn wd = ColumnCollection["WD"];
wd.ColumnType = SessionColumnType.WDAvg;
wd.IsComposite = true;
config = new SensorConfig()
{
StartDate = _startDate, EndDate = _endDate
};
wd.Configs.Add(config);
//get axis selections from UI
IAxis Xaxis = GetAxis(_xShearAxis, _xBinWidth);
IAxis Yaxis = GetAxis(_yShearAxis, _yBinWidth);
//calculate alpha
AlphaFactory afactory = new AlphaFactory();
Alpha alpha = (Alpha)afactory.CreateAlpha(_unifiedData, AlphaFilterMethod.Coincident, upperws, lowerws, Xaxis, Yaxis);
alpha.SourceDataSet = this.DisplayName;
alpha.CalculateAlpha();
string xBin = string.Empty;
string yBin = string.Empty;
if (Xaxis.AxisType == AxisType.WD)
{
var wdaxis = (WindDirectionAxis)Xaxis;
xBin = " " + wdaxis.BinWidth.ToString() + " deg";
}
if (Xaxis.AxisType == AxisType.WS)
{
var wsaxis = (WindSpeedAxis)Xaxis;
xBin = " " + wsaxis.BinWidth.ToString() + " m/s";
}
if (Yaxis.AxisType == AxisType.WD)
{
var wdaxis = (WindDirectionAxis)Yaxis;
yBin = " " + wdaxis.BinWidth.ToString() + " deg";
}
if (Yaxis.AxisType == AxisType.WS)
{
var wsaxis = (WindSpeedAxis)Yaxis;
yBin = " " + wsaxis.BinWidth.ToString() + " m/s";
}
//Set up column metadata for the summary run
summary = new XbyYShearStationSummary(ColumnCollection, _unifiedData.AsDataView(), 30, 10, 2, alpha);
summary.CreateReport(filename);
SummaryIsProcessing = false;
}
catch (ApplicationException e)
{
MessageBox.Show("Error calculating station summary: " + e.Message + " " + e.Source);
StreamWriter fs = new StreamWriter(Path.GetDirectoryName(filename) + @"\LOG_" + Path.GetFileNameWithoutExtension(filename) + ".txt", false);
summary.log.ForEach(c => fs.WriteLine(c));
fs.Close();
}
finally
{
SummaryIsProcessing = false;
}
};
worker.RunWorkerAsync();
}
internal override async void Drawing()
{
if (OwnerChart == null || OwnerChart.ItemsSource == null || OwnerChart.XAxis == null || OwnerChart.YAxis == null)
{
return;
}
IEnumerable <IList> items = OwnerChart.ItemsSource;
IAxis xaxis = OwnerChart.XAxis;
IAxis yaxis = OwnerChart.YAxis;
if (OwnerChart.X < 0)
{
OwnerChart.X = 0;
}
int x = OwnerChart.X;
if (OwnerChart.Y < 0)
{
OwnerChart.Y = 1;
}
int y = OwnerChart.Y;
using (var getdatatask = xaxis.GetHistogramViewData(items, x, Count))
{
var datas = await getdatatask;
if (datas.Count() <= 0)
{
var tempdc = DV.RenderOpen();
tempdc.DrawLine(new Pen(this.Stroke, 0), new Point(0, 0), new Point(0, 0));
tempdc.Close();
return;
}
var maxy = datas.Max(p => p.Value);
yaxis.Max = maxy * 1.2;
yaxis.Min = 0;
yaxis.Drawing();
var height = this.ActualHeight;
Func <double, ValueLocationConvertParam, double> YGetLocation = yaxis.GetValueLocation;
var yconvert = yaxis.GetConvertParam();
var task = Task.Run(() =>
{
var streamGeometry = new StreamGeometry()
{
FillRule = FillRule.EvenOdd
};
using (StreamGeometryContext sgc = streamGeometry.Open())
{
List <Point> points = new List <Point>();
foreach (var data in datas)
{
var yvalue = YGetLocation(data.Value, yconvert);
if (double.IsNaN(data.Key[0]) || double.IsInfinity(data.Key[0]) ||
double.IsNaN(data.Key[1]) || double.IsInfinity(data.Key[1]) ||
double.IsNaN(yvalue) || double.IsInfinity(yvalue))
{
continue;
}
points.Add(new Point(data.Key[0], yvalue));
points.Add(new Point(data.Key[1], yvalue));
}
if (points.Count > 0)
{
points.Add(new Point(points[points.Count - 1].X, height));
points.Add(new Point(points[0].X, height));
sgc.BeginFigure(new Point(points[0].X, height), true, true);
sgc.PolyLineTo(points, false, false);
}
else
{
sgc.BeginFigure(new Point(0, 0), true, true);
sgc.LineTo(new Point(0, 0), false, false);
}
sgc.Close();
}
streamGeometry.Freeze();
return(streamGeometry);
});
var geometryTemp = await task;
task.Dispose();
var dc = DV.RenderOpen();
base.ClearTransform();
dc.DrawGeometry(this.Fill, new Pen(this.Stroke, 1), geometryTemp);
dc.Close();
}
}
public override DimensinalBounds GetBounds(
CartesianChart <TDrawingContext> chart, IAxis <TDrawingContext> secondaryAxis, IAxis <TDrawingContext> primaryAxis)
{
var baseBounds = base.GetBounds(chart, secondaryAxis, primaryAxis);
var tick = primaryAxis.GetTick(chart.ControlSize, baseBounds.PrimaryBounds);
return(new DimensinalBounds
{
PrimaryBounds = new Bounds
{
Max = baseBounds.SecondaryBounds.Max + 0.5,
Min = baseBounds.SecondaryBounds.Min - 0.5
},
SecondaryBounds = new Bounds
{
Max = baseBounds.PrimaryBounds.Max + tick.Value,
Min = baseBounds.PrimaryBounds.Min < 0 ? baseBounds.PrimaryBounds.Min - tick.Value : 0
}
});
}
