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 } }); }