/// <summary> /// Determines whether the plot items in <paramref name="coll"/> can be plotted as stack. Presumption is that all plot items /// have the same number of plot points, and that all items have the same order of x values associated with the plot points. /// </summary> /// <param name="layer">Plot layer.</param> /// <param name="coll">Collection of plot items.</param> /// <param name="plotDataList">Output: dictionary with associates each plot item with a list of processed plot data.</param> /// <returns>Returns <c>true</c> if the plot items in <paramref name="coll"/> can be plotted as stack; otherwise, <c>false</c>.</returns> public static bool CanUseStyle(IPlotArea layer, PlotItemCollection coll, out Dictionary <G2DPlotItem, Processed2DPlotData> plotDataList) { plotDataList = new Dictionary <G2DPlotItem, Processed2DPlotData>(); AltaxoVariant[] xArray = null; int idx = -1; foreach (IGPlotItem pi in coll) { if (pi is G2DPlotItem) { idx++; var gpi = (G2DPlotItem)pi; Processed2DPlotData pdata = gpi.GetRangesAndPoints(layer); plotDataList.Add(gpi, pdata); if (null != pdata) { if (xArray == null) { xArray = new AltaxoVariant[pdata.RangeList.PlotPointCount]; int j = -1; foreach (int originalIndex in pdata.RangeList.OriginalRowIndices()) { j++; xArray[j] = pdata.GetXPhysical(originalIndex); } } else // this is not the first item { if (pdata.RangeList.PlotPointCount != xArray.Length) { return(false); } int j = -1; foreach (int originalIndex in pdata.RangeList.OriginalRowIndices()) { j++; if (xArray[j] != pdata.GetXPhysical(originalIndex)) { return(false); } } } } } } return(idx >= 1); }
public void Paint(System.Drawing.Graphics g, IPlotArea layer, PlotItemCollection coll) { System.Drawing.Region[] clippingColl = new System.Drawing.Region[coll.Count]; Processed2DPlotData[] plotDataColl = new Processed2DPlotData[coll.Count]; double[] xincColl = new double[coll.Count]; double[] yincColl = new double[coll.Count]; int idx = -1; Processed2DPlotData previousPlotData = null; for (int i = 0; i < coll.Count; i++) { if (coll[i] is G2DPlotItem) { idx++; double currxinc = xincColl[i] = idx * _xinc * _scaleXInc; double curryinc = yincColl[i] = idx * _yinc * _scaleYInc; G2DPlotItem gpi = coll[i] as G2DPlotItem; Processed2DPlotData plotdata = plotDataColl[i] = gpi.GetRangesAndPoints(layer); plotdata.PreviousItemData = previousPlotData; previousPlotData = plotdata; int j = -1; foreach (int rowIndex in plotdata.RangeList.OriginalRowIndices()) { j++; AltaxoVariant xx = plotdata.GetXPhysical(rowIndex) + currxinc; AltaxoVariant yy = plotdata.GetYPhysical(rowIndex) + curryinc; Logical3D rel = new Logical3D(layer.XAxis.PhysicalVariantToNormal(xx), layer.YAxis.PhysicalVariantToNormal(yy)); double xabs, yabs; layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out xabs, out yabs); plotdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs); } if (_useClipping) { GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath(); } } } for (int i = coll.Count - 1; i >= 0; i--) { if (null == plotDataColl[i]) { coll[i].Paint(g, layer); } else { TransformedLayerWrapper layerwrapper = new TransformedLayerWrapper(layer, xincColl[i], yincColl[i]); ((G2DPlotItem)coll[i]).Paint(g, layerwrapper, plotDataColl[i]); } } }
public void PaintPreprocessing(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll) { if (!CanUseStyle(layer, coll, out var plotDataDict)) { return; } else { paintContext.AddValue(this, plotDataDict); } AltaxoVariant[] ysumArray = null; foreach (IGPlotItem pi in coll) { if (pi is G2DPlotItem) { var gpi = pi as G2DPlotItem; Processed2DPlotData pdata = plotDataDict[gpi]; ysumArray = AbsoluteStackTransform.AddUp(ysumArray, pdata); } } // now plot the data - the summed up y is in yArray AltaxoVariant[] yArray = null; Processed2DPlotData previousItemData = null; foreach (IGPlotItem pi in coll) { if (pi is G2DPlotItem) { var gpi = pi as G2DPlotItem; Processed2DPlotData pdata = plotDataDict[gpi]; yArray = AbsoluteStackTransform.AddUp(yArray, pdata); var localArray = new AltaxoVariant[yArray.Length]; int j = -1; foreach (int originalIndex in pdata.RangeList.OriginalRowIndices()) { j++; AltaxoVariant y = 100 * yArray[j] / ysumArray[j]; localArray[j] = y; var rel = new Logical3D( layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)), layer.YAxis.PhysicalVariantToNormal(y)); layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var xabs, out var yabs); pdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs); } // we have also to exchange the accessor for the physical y value and replace it by our own one pdata.YPhysicalAccessor = new IndexedPhysicalValueAccessor(delegate(int i) { return(localArray[i]); }); pdata.PreviousItemData = previousItemData; previousItemData = pdata; } } }
public void PaintPreprocessing(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll) { if (!CanUseStyle(layer, coll, out var plotDataDict)) { return; } else { paintContext.AddValue(this, plotDataDict); } AltaxoVariant[] yArray = null; // First, add up all items since we start always with the last item int idx = -1; Processed2DPlotData previousItemData = null; foreach (IGPlotItem pi in coll) { if (pi is G2DPlotItem) { idx++; var gpi = pi as G2DPlotItem; Processed2DPlotData pdata = plotDataDict[gpi]; if (null == pdata) { continue; } yArray = AddUp(yArray, pdata); if (idx > 0) // this is not the first item { int j = -1; foreach (int originalIndex in pdata.RangeList.OriginalRowIndices()) { j++; var rel = new Logical3D( layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)), layer.YAxis.PhysicalVariantToNormal(yArray[j])); layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var xabs, out var yabs); pdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs); } } // we have also to exchange the accessor for the physical y value and replace it by our own one var localArray = (AltaxoVariant[])yArray.Clone(); var localArrayHolder = new LocalArrayHolder(localArray, pdata); pdata.YPhysicalAccessor = localArrayHolder.GetPhysical; pdata.PreviousItemData = previousItemData; previousItemData = pdata; } } }
public void PrepareGroupStyles(PlotGroupStyleCollection externalGroups, PlotGroupStyleCollection localGroups, IPlotArea layer, Processed2DPlotData pdata) { // first, we have to calculate the span of logical values from the minimum logical value to the maximum logical value int numberOfItems = 0; if (null != pdata) { double minLogicalX = double.MaxValue; double maxLogicalX = double.MinValue; foreach (int originalRowIndex in pdata.RangeList.OriginalRowIndices()) { numberOfItems++; double logicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalRowIndex)); if (logicalX < minLogicalX) { minLogicalX = logicalX; } if (logicalX > maxLogicalX) { maxLogicalX = logicalX; } } BarSizePosition2DGroupStyle.IntendToApply(externalGroups, localGroups, numberOfItems, minLogicalX, maxLogicalX); } BarSizePosition2DGroupStyle bwp = PlotGroupStyle.GetStyleToInitialize <BarSizePosition2DGroupStyle>(externalGroups, localGroups); if (null != bwp) { bwp.Initialize(_relInnerGapX, _relOuterGapX); } if (!_independentFillColor && null != _fillBrush) { ColorGroupStyle.PrepareStyle(externalGroups, localGroups, delegate() { return(_fillBrush.Color); }); } else if (!_independentFrameColor && null != _framePen) // else if is used here because fill color has precedence over frame color { ColorGroupStyle.PrepareStyle(externalGroups, localGroups, delegate() { return(_framePen.Color); }); } }
public void PrepareGroupStyles(PlotGroupStyleCollection externalGroups, PlotGroupStyleCollection localGroups, IPlotArea layer, Processed2DPlotData pdata) { // first, we have to calculate the span of logical values from the minimum logical value to the maximum logical value int numberOfItems = 0; double minLogical = double.MaxValue; double maxLogical = double.MinValue; foreach (int originalRowIndex in pdata.RangeList.OriginalRowIndices()) { double logicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalRowIndex)); numberOfItems++; if (logicalX < minLogical) { minLogical = logicalX; } if (logicalX > maxLogical) { maxLogical = logicalX; } } BarWidthPositionGroupStyle.IntendToApply(externalGroups, localGroups, numberOfItems, minLogical, maxLogical); BarWidthPositionGroupStyle bwp = PlotGroupStyle.GetStyleToInitialize <BarWidthPositionGroupStyle>(externalGroups, localGroups); if (null != bwp) { bwp.Initialize(_relInnerGapWidth, _relOuterGapWidth); } if (this.IsColorReceiver) { ColorGroupStyle.PrepareStyle(externalGroups, localGroups, delegate() { return(PlotColors.Colors.GetPlotColor(this._fillBrush.Color)); }); } }
public void Paint(System.Drawing.Graphics g, IPlotArea layer, Processed2DPlotData pdata, Processed2DPlotData prevItemData, Processed2DPlotData nextItemData) { if (null == pdata) { throw new ArgumentNullException(nameof(pdata)); } PlotRangeList rangeList = pdata.RangeList; System.Drawing.PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; layer.CoordinateSystem.LogicalToLayerCoordinates(new Logical3D(0, 0), out var xleft, out var ybottom); layer.CoordinateSystem.LogicalToLayerCoordinates(new Logical3D(1, 1), out var xright, out var ytop); float xe = (float)xright; float ye = (float)ybottom; var path = new GraphicsPath(); double globalBaseValue; if (_usePhysicalBaseValue) { globalBaseValue = layer.YAxis.PhysicalVariantToNormal(_baseValue); if (double.IsNaN(globalBaseValue)) { globalBaseValue = 0; } } else { globalBaseValue = _baseValue.ToDouble(); } bool useVariableFillColor = null != _fillBrush && null != _cachedColorForIndexFunction && !_independentFillColor; bool useVariableFrameColor = null != _framePen && null != _cachedColorForIndexFunction && !_independentFrameColor; var fillBrush = _fillBrush == null ? null : useVariableFillColor?_fillBrush.Clone() : _fillBrush; var framePen = _framePen == null ? null : useVariableFrameColor?_framePen.Clone() : _framePen; int j = -1; foreach (int originalRowIndex in pdata.RangeList.OriginalRowIndices()) { j++; double xcn = _xOffsetLogical + layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalRowIndex)); double xln = xcn - 0.5 * _xSizeLogical; double xrn = xcn + 0.5 * _xSizeLogical; double ycn = layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalRowIndex)); double ynbase = globalBaseValue; if (_startAtPreviousItem && pdata.PreviousItemData != null) { double prevstart = layer.YAxis.PhysicalVariantToNormal(pdata.PreviousItemData.GetYPhysical(originalRowIndex)); if (!double.IsNaN(prevstart)) { ynbase = prevstart; ynbase += Math.Sign(ynbase - globalBaseValue) * _previousItemYGap; } } path.Reset(); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xln, ynbase), new Logical3D(xln, ycn)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xln, ycn), new Logical3D(xrn, ycn)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xrn, ycn), new Logical3D(xrn, ynbase)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xrn, ynbase), new Logical3D(xln, ynbase)); path.CloseFigure(); if (null != fillBrush) { if (useVariableFillColor) { fillBrush.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor"); } fillBrush.SetEnvironment(path.GetBounds(), BrushX.GetEffectiveMaximumResolution(g, 1)); g.FillPath(fillBrush, path); } if (null != framePen) { if (useVariableFrameColor) { framePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor"); } framePen.SetEnvironment(path.GetBounds(), BrushX.GetEffectiveMaximumResolution(g, 1)); g.DrawPath(framePen, path); } } }
protected void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { const double logicalClampMinimum = -10; const double logicalClampMaximum = 11; // Plot error bars for the dependent variable (y) var columnX = ColumnX; var columnY = ColumnY; if (columnX == null || columnY == null) { return; // nothing to do if both error columns are null } if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType)) { return; // TODO make this an runtime paint error to be reported } var strokePen = _strokePen.Clone(); using (var isoLine = new GraphicsPath()) { int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex); strokePen.Width = (_lineWidth1Offset + _lineWidth1Factor * symbolSize); if (null != _cachedColorForIndexFunction) { strokePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor"); } if (!(strokePen.EndCap is LineCaps.FlatCap)) { strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6); } // Calculate target AltaxoVariant targetX, targetY; switch (_meaningOfValues) { case ValueInterpretation.AbsoluteDifference: { targetX = pdata.GetXPhysical(originalRowIndex) + columnX[originalRowIndex]; targetY = pdata.GetYPhysical(originalRowIndex) + columnY[originalRowIndex]; } break; case ValueInterpretation.AbsoluteValue: { targetX = columnX[originalRowIndex]; targetY = columnY[originalRowIndex]; } break; default: throw new NotImplementedException(nameof(_meaningOfValues)); } var logicalTarget = layer.GetLogical3D(targetX, targetY); var logicalOrigin = layer.GetLogical3D(pdata, originalRowIndex); if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY)) { logicalOrigin.RX += _cachedLogicalShiftX; logicalOrigin.RY += _cachedLogicalShiftY; logicalTarget.RX += _cachedLogicalShiftX; logicalTarget.RY += _cachedLogicalShiftY; } if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum)) { continue; } if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum)) { continue; } if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum)) { continue; } if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum)) { continue; } if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum)) { continue; } if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum)) { continue; } isoLine.Reset(); layer.CoordinateSystem.GetIsoline(isoLine, logicalOrigin, logicalTarget); if (null == isoLine) { continue; } PointF[] isoLinePathPoints = null; if (_useManualVectorLength) { isoLine.Flatten(); isoLinePathPoints = isoLine.PathPoints; double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize; double isoLineLength = isoLinePathPoints.TotalLineLength(); isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length)); if (null == isoLine) { continue; } } if (_useSymbolGap) { if (null == isoLinePathPoints) { isoLine.Flatten(); isoLinePathPoints = isoLine.PathPoints; } double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap != 0) { isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); if (null == isoLine) { continue; } } } if (null != isoLinePathPoints) { g.DrawLines(_strokePen, isoLinePathPoints); } else { g.DrawPath(strokePen, isoLine); } } } }
public void PaintPreprocessing(System.Drawing.Graphics g, IPaintContext paintContext, IPlotArea layer, PlotItemCollection coll) { var paintData = new CachedPaintData { _clippingColl = new System.Drawing.Region[coll.Count], _plotDataColl = new Processed2DPlotData[coll.Count], _xincColl = new double[coll.Count], _yincColl = new double[coll.Count] }; paintContext.AddValue(this, paintData); // First prepare int idx = -1; Processed2DPlotData previousPlotData = null; for (int i = 0; i < coll.Count; i++) { if (coll[i] is G2DPlotItem) { idx++; double currxinc = paintData._xincColl[i] = idx * _xinc * _scaleXInc; double curryinc = paintData._yincColl[i] = idx * _yinc * _scaleYInc; var gpi = coll[i] as G2DPlotItem; Processed2DPlotData plotdata = paintData._plotDataColl[i] = gpi.GetRangesAndPoints(layer); plotdata.PreviousItemData = previousPlotData; previousPlotData = plotdata; int j = -1; foreach (int rowIndex in plotdata.RangeList.OriginalRowIndices()) { j++; AltaxoVariant xx = plotdata.GetXPhysical(rowIndex) + currxinc; AltaxoVariant yy = plotdata.GetYPhysical(rowIndex) + curryinc; var rel = new Logical3D(layer.XAxis.PhysicalVariantToNormal(xx), layer.YAxis.PhysicalVariantToNormal(yy)); layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out var xabs, out var yabs); plotdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs); } // if clipping is used, we must get a clipping region for every plot item // and combine the regions from if (_useClipping) { if (i == 0) { paintData._clippingColl[i] = g.Clip; } Plot.Styles.LinePlotStyle linestyle = null; foreach (Plot.Styles.IG2DPlotStyle st in gpi.Style) { if (st is Plot.Styles.LinePlotStyle) { linestyle = st as Plot.Styles.LinePlotStyle; break; } } if (null != linestyle) { var path = new System.Drawing.Drawing2D.GraphicsPath(); linestyle.GetFillPath(path, layer, plotdata, CSPlaneID.Bottom); if ((i + 1) < paintData._clippingColl.Length) { paintData._clippingColl[i + 1] = paintData._clippingColl[i].Clone(); paintData._clippingColl[i + 1].Exclude(path); } } else { if ((i + 1) < paintData._clippingColl.Length) { paintData._clippingColl[i + 1] = paintData._clippingColl[i]; } } } } } }
public void StraightConnection_PaintOneRange( Graphics g, Processed2DPlotData pdata, PlotRange range, IPlotArea layer, Processed2DPlotData previousData) { PointF[] linePoints = pdata.PlotPointsInAbsoluteLayerCoordinates; var linepts = new PointF[range.Length]; Array.Copy(linePoints, range.LowerBound, linepts, 0, range.Length); // Extract int lastIdx = range.Length - 1; // Try to find points with a similar x value on otherlinepoints double firstLogicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(range.OriginalFirstPoint)); double lastLogicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(range.OriginalLastPoint)); double minDistanceToFirst = double.MaxValue; double minDistanceToLast = double.MaxValue; int minIdxFirst = -1; int minIdxLast = -1; foreach (var rangeP in previousData.RangeList) { for (int i = rangeP.LowerBound; i < rangeP.UpperBound; ++i) { double logicalX = layer.XAxis.PhysicalVariantToNormal(previousData.GetXPhysical(i + rangeP.OffsetToOriginal)); if (Math.Abs(logicalX - firstLogicalX) < minDistanceToFirst) { minDistanceToFirst = Math.Abs(logicalX - firstLogicalX); minIdxFirst = i; } if (Math.Abs(logicalX - lastLogicalX) < minDistanceToLast) { minDistanceToLast = Math.Abs(logicalX - lastLogicalX); minIdxLast = i; } } } // if nothing found, use the outmost boundaries of the plot points of the other data item if (minIdxFirst < 0) { minIdxFirst = 0; } if (minIdxLast < 0) { minIdxLast = previousData.PlotPointsInAbsoluteLayerCoordinates.Length - 1; } var otherLinePoints = new PointF[minIdxLast + 1 - minIdxFirst]; Array.Copy(previousData.PlotPointsInAbsoluteLayerCoordinates, minIdxFirst, otherLinePoints, 0, otherLinePoints.Length); Array.Reverse(otherLinePoints); // now paint this var gp = new GraphicsPath(); var layerSize = layer.Size; gp.StartFigure(); gp.AddLines(linepts); gp.AddLines(otherLinePoints); gp.CloseFigure(); if (_fillBrush.IsVisible) { g.FillPath(_fillBrush, gp); } if (null != _framePen) { g.DrawPath(_framePen, gp); } gp.Reset(); } // end function PaintOneRange
public void StraightConnection_PaintOneRange( Graphics g, Processed2DPlotData pdata, PlotRange range, IPlotArea layer, Processed2DPlotData previousData) { PointF[] linePoints = pdata.PlotPointsInAbsoluteLayerCoordinates; PointF[] linepts = new PointF[range.Length]; Array.Copy(linePoints, range.LowerBound, linepts, 0, range.Length); // Extract int lastIdx = range.Length - 1; // Try to find points with a similar x value on otherlinepoints double firstLogicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(range.OriginalFirstPoint)); double lastLogicalX = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(range.OriginalLastPoint)); double minDistanceToFirst = double.MaxValue; double minDistanceToLast = double.MaxValue; int minIdxFirst = -1; int minIdxLast = -1; foreach (var rangeP in previousData.RangeList) { for (int i = rangeP.LowerBound; i < rangeP.UpperBound; ++i) { double logicalX = layer.XAxis.PhysicalVariantToNormal(previousData.GetXPhysical(i + rangeP.OffsetToOriginal)); if (Math.Abs(logicalX - firstLogicalX) < minDistanceToFirst) { minDistanceToFirst = Math.Abs(logicalX - firstLogicalX); minIdxFirst = i; } if (Math.Abs(logicalX - lastLogicalX) < minDistanceToLast) { minDistanceToLast = Math.Abs(logicalX - lastLogicalX); minIdxLast = i; } } } // if nothing found, use the outmost boundaries of the plot points of the other data item if (minIdxFirst < 0) minIdxFirst = 0; if (minIdxLast < 0) minIdxLast = previousData.PlotPointsInAbsoluteLayerCoordinates.Length - 1; PointF[] otherLinePoints = new PointF[minIdxLast + 1 - minIdxFirst]; Array.Copy(previousData.PlotPointsInAbsoluteLayerCoordinates, minIdxFirst, otherLinePoints, 0, otherLinePoints.Length); Array.Reverse(otherLinePoints); // now paint this GraphicsPath gp = new GraphicsPath(); var layerSize = layer.Size; gp.StartFigure(); gp.AddLines(linepts); gp.AddLines(otherLinePoints); gp.CloseFigure(); if (_fillBrush.IsVisible) { g.FillPath(this._fillBrush, gp); } if (null != _framePen) g.DrawPath(_framePen, gp); gp.Reset(); } // end function PaintOneRange
protected void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { const double logicalClampMinimum = -10; const double logicalClampMaximum = 11; // Plot error bars for the dependent variable (y) var columnX = ColumnX; var columnY = ColumnY; if (columnX == null || columnY == null) return; // nothing to do if both error columns are null if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType)) return; // TODO make this an runtime paint error to be reported var strokePen = _strokePen.Clone(); using (GraphicsPath isoLine = new GraphicsPath()) { int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex); strokePen.Width = (_lineWidth1Offset + _lineWidth1Factor * symbolSize); if (null != _cachedColorForIndexFunction) strokePen.Color = GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRowIndex), "VariableColor"); if (!(strokePen.EndCap is LineCaps.FlatCap)) strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6); // Calculate target AltaxoVariant targetX, targetY; switch (_meaningOfValues) { case ValueInterpretation.AbsoluteDifference: { targetX = pdata.GetXPhysical(originalRowIndex) + columnX[originalRowIndex]; targetY = pdata.GetYPhysical(originalRowIndex) + columnY[originalRowIndex]; } break; case ValueInterpretation.AbsoluteValue: { targetX = columnX[originalRowIndex]; targetY = columnY[originalRowIndex]; } break; default: throw new NotImplementedException(nameof(_meaningOfValues)); } var logicalTarget = layer.GetLogical3D(targetX, targetY); var logicalOrigin = layer.GetLogical3D(pdata, originalRowIndex); if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY)) { logicalOrigin.RX += _cachedLogicalShiftX; logicalOrigin.RY += _cachedLogicalShiftY; logicalTarget.RX += _cachedLogicalShiftX; logicalTarget.RY += _cachedLogicalShiftY; } if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RX, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RY, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalOrigin.RZ, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalTarget.RX, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalTarget.RY, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalTarget.RZ, logicalClampMinimum, logicalClampMaximum)) continue; isoLine.Reset(); layer.CoordinateSystem.GetIsoline(isoLine, logicalOrigin, logicalTarget); if (null == isoLine) continue; PointF[] isoLinePathPoints = null; if (_useManualVectorLength) { isoLine.Flatten(); isoLinePathPoints = isoLine.PathPoints; double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize; double isoLineLength = isoLinePathPoints.TotalLineLength(); isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length)); if (null == isoLine) continue; } if (_useSymbolGap) { if (null == isoLinePathPoints) { isoLine.Flatten(); isoLinePathPoints = isoLine.PathPoints; } double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap != 0) { isoLinePathPoints = isoLinePathPoints.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); if (null == isoLine) continue; } } if (null != isoLinePathPoints) g.DrawLines(_strokePen, isoLinePathPoints); else g.DrawPath(strokePen, isoLine); } } }
public void Paint(System.Drawing.Graphics g, IPlotArea layer, Processed2DPlotData pdata) { PlotRangeList rangeList = pdata.RangeList; System.Drawing.PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; // paint the drop style double xleft, xright, ytop, ybottom; layer.CoordinateSystem.LogicalToLayerCoordinates(new Logical3D(0, 0), out xleft, out ybottom); layer.CoordinateSystem.LogicalToLayerCoordinates(new Logical3D(1, 1), out xright, out ytop); float xe = (float)xright; float ye = (float)ybottom; GraphicsPath path = new GraphicsPath(); double globalBaseValue; if (_usePhysicalBaseValue) { globalBaseValue = layer.YAxis.PhysicalVariantToNormal(_baseValue); if (double.IsNaN(globalBaseValue)) { globalBaseValue = 0; } } else { globalBaseValue = _baseValue.ToDouble(); } int j = -1; foreach (int originalRowIndex in pdata.RangeList.OriginalRowIndices()) { j++; double xcn = layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalRowIndex)); double xln = xcn + _position; double xrn = xln + _width; double ycn = layer.YAxis.PhysicalVariantToNormal(pdata.GetYPhysical(originalRowIndex)); double ynbase = globalBaseValue; if (_startAtPreviousItem && pdata.PreviousItemData != null) { double prevstart = layer.YAxis.PhysicalVariantToNormal(pdata.PreviousItemData.GetYPhysical(originalRowIndex)); if (!double.IsNaN(prevstart)) { ynbase = prevstart; ynbase += Math.Sign(ynbase - globalBaseValue) * _previousItemYGap; } } path.Reset(); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xln, ynbase), new Logical3D(xln, ycn)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xln, ycn), new Logical3D(xrn, ycn)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xrn, ycn), new Logical3D(xrn, ynbase)); layer.CoordinateSystem.GetIsoline(path, new Logical3D(xrn, ynbase), new Logical3D(xln, ynbase)); path.CloseFigure(); _fillBrush.Rectangle = path.GetBounds(); g.FillPath(_fillBrush, path); if (_framePen != null) { _framePen.BrushRectangle = path.GetBounds(); g.DrawPath(_framePen, path); } } }
public void Paint(System.Drawing.Graphics g, IPlotArea layer, PlotItemCollection coll) { Dictionary <G2DPlotItem, Processed2DPlotData> plotDataDict; if (!CanUseStyle(layer, coll, out plotDataDict)) { CoordinateTransformingStyleBase.Paint(g, layer, coll); return; } AltaxoVariant[] yArray = null; // First, add up all items since we start always with the last item int idx = -1; Processed2DPlotData previousItemData = null; foreach (IGPlotItem pi in coll) { if (pi is G2DPlotItem) { idx++; G2DPlotItem gpi = pi as G2DPlotItem; Processed2DPlotData pdata = plotDataDict[gpi]; yArray = AddUp(yArray, pdata); if (idx > 0) // this is not the first item { int j = -1; foreach (int originalIndex in pdata.RangeList.OriginalRowIndices()) { j++; Logical3D rel = new Logical3D( layer.XAxis.PhysicalVariantToNormal(pdata.GetXPhysical(originalIndex)), layer.YAxis.PhysicalVariantToNormal(yArray[j])); double xabs, yabs; layer.CoordinateSystem.LogicalToLayerCoordinates(rel, out xabs, out yabs); pdata.PlotPointsInAbsoluteLayerCoordinates[j] = new System.Drawing.PointF((float)xabs, (float)yabs); } } // we have also to exchange the accessor for the physical y value and replace it by our own one AltaxoVariant[] localArray = (AltaxoVariant[])yArray.Clone(); pdata.YPhysicalAccessor = new IndexedPhysicalValueAccessor(delegate(int i) { return(localArray[i]); }); pdata.PreviousItemData = previousItemData; previousItemData = pdata; } } for (int i = coll.Count - 1; i >= 0; --i) { IGPlotItem pi = coll[i]; if (pi is G2DPlotItem) { G2DPlotItem gpi = pi as G2DPlotItem; Processed2DPlotData pdata = plotDataDict[gpi]; gpi.Paint(g, layer, pdata); } else { pi.Paint(g, layer); } } }