/// <summary> /// Template to get a fill path. /// </summary> /// <param name="gp">Graphics path to fill with data.</param> /// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param> /// <param name="range">The plot range to use.</param> /// <param name="layer">Graphics layer.</param> /// <param name="fillDirection">Designates a bound to fill to.</param> /// <param name="linePoints">The points that mark the line.</param> /// <param name="connectCircular">If true, a circular connection is drawn.</param> private void FillOneRange_PreprocessedPoints( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, PointF[] linePoints, bool connectCircular, double logicalShiftX, double logicalShiftY ) { if (connectCircular) { gp.AddBeziers(linePoints); gp.CloseFigure(); } else { Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddBeziers(linePoints); Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + linePoints.Length - 1)); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.CloseFigure(); } }
/// <inheritdoc/> public override void FillOneRange( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, bool ignoreMissingDataPoints, bool connectCircular, PointF[] allLinePointsShiftedAlready, double logicalShiftX, double logicalShiftY ) { if (range.Length < 2) { return; } PointF[] linePoints = Segment2Connection_GetSubPoints(allLinePointsShiftedAlready, range, layer, connectCircular, out var lastIdx); if (connectCircular) { gp.AddLines(linePoints); gp.CloseFigure(); } else { int offs = range.LowerBound; for (int i = 0; i < linePoints.Length - 1; i += 2) { Logical3D r0 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i)); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddLine(linePoints[i].X, linePoints[i].Y, linePoints[i + 1].X, linePoints[i + 1].Y); Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i + 1)); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.StartFigure(); } gp.CloseFigure(); } }
/// <inheritdoc/> public override void FillOneRange( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, bool ignoreMissingDataPoints, bool connectCircular, PointF[] allLinePoints, double logicalShiftX, double logicalShiftY ) { var circularLinePoints = new PointF[range.Length + (connectCircular ? 1 : 0)]; Array.Copy(allLinePoints, range.LowerBound, circularLinePoints, 0, range.Length); // Extract if (connectCircular) { circularLinePoints[circularLinePoints.Length - 1] = circularLinePoints[0]; } if (connectCircular) { gp.AddLines(circularLinePoints); gp.CloseFigure(); } else // not circular { Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddLines(circularLinePoints); Logical3D r1 = layer.GetLogical3D(pdata, connectCircular ? range.OriginalFirstPoint : range.OriginalLastPoint); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.CloseFigure(); } }
/// <summary> /// Template to get a fill path. /// </summary> /// <param name="gp">Graphics path to fill with data.</param> /// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param> /// <param name="range">The plot range to use.</param> /// <param name="layer">Graphics layer.</param> /// <param name="fillDirection">Designates a bound to fill to.</param> /// <param name="linePoints">The points that mark the line.</param> /// <param name="connectCircular">If true, a circular connection is drawn.</param> /// <param name="allLinePointsShiftedAlready">The plot positions, already shifted when a logical shift needed to be applied. Don't use the Range property of the pdata, since it is overriden by the next argument.</param> /// <param name="logicalShiftX">The logical shift in x-direction.</param> /// <param name="logicalShiftY">The logical shift in x-direction.</param> public virtual void FillOneRange( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, PointF[] linePoints, bool connectCircular, PointF[] allLinePointsShiftedAlready, double logicalShiftX, double logicalShiftY ) { if (connectCircular) { gp.AddLines(linePoints); gp.CloseFigure(); } else { Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddLines(linePoints); Logical3D r1 = layer.GetLogical3D(pdata, range.OriginalLastPoint); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.CloseFigure(); } }
/// <summary> /// Shift the plot points provided in <paramref name="pdata"/> with a logical shift in x- and/or y- direction. /// </summary> /// <param name="pdata">The plot point position data.</param> /// <param name="layer">The plot layer for which the data are intended.</param> /// <param name="logicalShiftX">The logical shift in x-direction.</param> /// <param name="logicalShiftY">The logical shift in y-direction.</param> /// <returns>Array of plot point positions, but now shifted by logical values in x-direction (<paramref name="logicalShiftX"/>) and y-direction (<paramref name="logicalShiftY"/>).</returns> public static PointF[] GetPlotPointsInAbsoluteLayerCoordinatesWithShift(Processed2DPlotData pdata, IPlotArea layer, double logicalShiftX, double logicalShiftY) { var result = new PointF[pdata.PlotPointsInAbsoluteLayerCoordinates.Length]; foreach (PlotRange r in pdata.RangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; ++j) { int originalRow = j + offset; Logical3D logicalMean = layer.GetLogical3D(pdata, originalRow); logicalMean.RX += logicalShiftX; logicalMean.RY += logicalShiftY; layer.CoordinateSystem.LogicalToLayerCoordinates(logicalMean, out var x, out var y); result[j] = new PointF((float)x, (float)y); } } return(result); }
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata) { PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) _skipFreq = 1; // paint the drop style if (this.DropLine.Count>0) { foreach (CSPlaneID id in _dropLine) layer.UpdateCSPlaneID(id); int rangeidx = 0; PlotRange range = pdata.RangeList[rangeidx]; for (int j = 0; j < ptArray.Length; j += _skipFreq) { // syncronize range while (j >= range.UpperBound) { rangeidx++; range = pdata.RangeList[rangeidx]; } Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal); foreach(CSPlaneID id in _dropLine) layer.CoordinateSystem.DrawIsolineFromPointToPlane(g,this._pen, r3d, id); } } // end paint the drop style // paint the scatter style if (this.Shape != XYPlotScatterStyles.Shape.NoSymbol) { // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); float xpos = 0, ypos = 0; float xdiff, ydiff; for (int j = 0; j < ptArray.Length; j += _skipFreq) { xdiff = ptArray[j].X - xpos; ydiff = ptArray[j].Y - ypos; xpos = ptArray[j].X; ypos = ptArray[j].Y; g.TranslateTransform(xdiff, ydiff); this.Paint(g); } // end for g.Restore(gs); // Restore the graphics state } }
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData) { if (this._labelColumnProxy.Document == null) return; if (null != _attachedPlane) _attachedPlane = layer.UpdateCSPlaneID(_attachedPlane); PlotRangeList rangeList = pdata.RangeList; var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; Altaxo.Data.IReadableColumn labelColumn = this._labelColumnProxy.Document; bool isUsingVariableColorForLabelText = null != _cachedColorForIndexFunction && IsColorReceiver; bool isUsingVariableColorForLabelBackground = null != _cachedColorForIndexFunction && (null != _backgroundStyle && _backgroundStyle.SupportsUserDefinedMaterial && (_backgroundColorLinkage == ColorLinkage.Dependent || _backgroundColorLinkage == ColorLinkage.PreserveAlpha)); bool isUsingVariableColor = isUsingVariableColorForLabelText || isUsingVariableColorForLabelBackground; IMaterial clonedTextBrush = _material; IMaterial clonedBackBrush = null; if (isUsingVariableColorForLabelBackground) clonedBackBrush = _backgroundStyle.Material; // save the graphics stat since we have to translate the origin var gs = g.SaveGraphicsState(); double xpos = 0, ypos = 0, zpos = 0; double xpre, ypre, zpre; double xdiff, ydiff, zdiff; bool isFormatStringContainingBraces = _labelFormatString?.IndexOf('{') >= 0; var culture = System.Threading.Thread.CurrentThread.CurrentCulture; bool mustUseLogicalCoordinates = null != this._attachedPlane || 0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ; for (int r = 0; r < rangeList.Count; r++) { int lower = rangeList[r].LowerBound; int upper = rangeList[r].UpperBound; int offset = rangeList[r].OffsetToOriginal; for (int j = lower; j < upper; j += _skipFrequency) { string label; if (string.IsNullOrEmpty(_labelFormatString)) { label = labelColumn[j + offset].ToString(); } else if (!isFormatStringContainingBraces) { label = labelColumn[j + offset].ToString(_labelFormatString, culture); } else { // the label format string can contain {0} for the label column item, {1} for the row index, {2} .. {4} for the x, y and z component of the data point label = string.Format(_labelFormatString, labelColumn[j + offset], j + offset, pdata.GetPhysical(0, j + offset), pdata.GetPhysical(1, j + offset), pdata.GetPhysical(2, j + offset)); } if (string.IsNullOrEmpty(label)) continue; double localSymbolSize = _symbolSize; if (null != _cachedSymbolSizeForIndexFunction) { localSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset); } double localFontSize = _fontSizeOffset + _fontSizeFactor * localSymbolSize; if (!(localFontSize > 0)) continue; _font = _font.WithSize(localFontSize); // Start of preparation of brushes, if a variable color is used if (isUsingVariableColor) { var c = _cachedColorForIndexFunction(j + offset); if (isUsingVariableColorForLabelText) { clonedTextBrush = clonedTextBrush.WithColor(new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e")); } if (isUsingVariableColorForLabelBackground) { if (_backgroundColorLinkage == ColorLinkage.PreserveAlpha) clonedBackBrush = clonedBackBrush.WithColor(new NamedColor(AxoColor.FromArgb(clonedBackBrush.Color.Color.A, c.R, c.G, c.B), "e")); else clonedBackBrush = clonedBackBrush.WithColor(new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e")); } } // end of preparation of brushes for variable colors if (mustUseLogicalCoordinates) // we must use logical coordinates because either there is a shift of logical coordinates, or an attached plane { Logical3D r3d = layer.GetLogical3D(pdata, j + offset); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; r3d.RZ += _cachedLogicalShiftZ; if (null != this._attachedPlane) { var pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d); xpre = pp.X; ypre = pp.Y; zpre = pp.Z; } else { PointD3D pt; layer.CoordinateSystem.LogicalToLayerCoordinates(r3d, out pt); xpre = pt.X; ypre = pt.Y; zpre = pt.Z; } } else // no shifting, thus we can use layer coordinates { xpre = ptArray[j].X; ypre = ptArray[j].Y; zpre = ptArray[j].Z; } xdiff = xpre - xpos; ydiff = ypre - ypos; zdiff = zpre - zpos; xpos = xpre; ypos = ypre; zpos = zpre; g.TranslateTransform(xdiff, ydiff, zdiff); g.RotateTransform(_rotationX, _rotationY, _rotationZ); this.Paint(g, label, localSymbolSize, clonedTextBrush, clonedBackBrush); g.RotateTransform(-_rotationX, -_rotationY, -_rotationZ); } // end for } g.RestoreGraphicsState(gs); // Restore the graphics state }
/// <summary> /// Shift the plot points provided in <paramref name="pdata"/> with a logical shift in x- and/or y- direction. /// </summary> /// <param name="pdata">The plot point position data.</param> /// <param name="layer">The plot layer for which the data are intended.</param> /// <param name="logicalShiftX">The logical shift in x-direction.</param> /// <param name="logicalShiftY">The logical shift in y-direction.</param> /// <returns>Array of plot point positions, but now shifted by logical values in x-direction (<paramref name="logicalShiftX"/>) and y-direction (<paramref name="logicalShiftY"/>).</returns> public static PointF[] GetPlotPointsInAbsoluteLayerCoordinatesWithShift(Processed2DPlotData pdata, IPlotArea layer, double logicalShiftX, double logicalShiftY) { var result = new PointF[pdata.PlotPointsInAbsoluteLayerCoordinates.Length]; foreach (PlotRange r in pdata.RangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; ++j) { int originalRow = j + offset; Logical3D logicalMean = layer.GetLogical3D(pdata, originalRow); logicalMean.RX += logicalShiftX; logicalMean.RY += logicalShiftY; double x, y; layer.CoordinateSystem.LogicalToLayerCoordinates(logicalMean, out x, out y); result[j] = new PointF((float)x, (float)y); } } return result; }
protected void PaintXErrorBars(System.Drawing.Graphics g, IPlotArea layer, Altaxo.Graph.Gdi.Plot.Data.Processed2DPlotData pdata) { // Plot error bars for the independent variable (x) PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; INumericColumn posErrCol = _positiveErrorColumn.Document; INumericColumn negErrCol = _negativeErrorColumn.Document; if (posErrCol == null && negErrCol == null) { return; // nothing to do if both error columns are null } System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath(); Region oldClippingRegion = g.Clip; Region newClip = (Region)oldClippingRegion.Clone(); foreach (PlotRange r in rangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; j++) { AltaxoVariant x = pdata.GetXPhysical(j + offset); Logical3D lm = layer.GetLogical3D(pdata, j + offset); lm.RX += _cachedLogicalShiftOfIndependent; if (lm.IsNaN) { continue; } Logical3D lh = lm; Logical3D ll = lm; bool lhvalid = false; bool llvalid = false; if (posErrCol != null) { lh.RX = layer.XAxis.PhysicalVariantToNormal(x + Math.Abs(posErrCol[j + offset])); lhvalid = !lh.IsNaN; } if (negErrCol != null) { ll.RX = layer.XAxis.PhysicalVariantToNormal(x - Math.Abs(negErrCol[j + offset])); llvalid = !ll.IsNaN; } if (!(lhvalid || llvalid)) { continue; // nothing to do for this point if both pos and neg logical point are invalid. } // now paint the error bar if (_symbolGap) // if symbol gap, then clip the painting, exclude a rectangle of size symbolSize x symbolSize { double xlm, ylm; layer.CoordinateSystem.LogicalToLayerCoordinates(lm, out xlm, out ylm); newClip.Union(oldClippingRegion); newClip.Exclude(new RectangleF((float)(xlm - _symbolSize / 2), (float)(ylm - _symbolSize / 2), _symbolSize, _symbolSize)); g.Clip = newClip; } if (lhvalid && llvalid) { errorBarPath.Reset(); layer.CoordinateSystem.GetIsoline(errorBarPath, ll, lm); layer.CoordinateSystem.GetIsoline(errorBarPath, lm, lh); g.DrawPath(_strokePen, errorBarPath); } else if (llvalid) { layer.CoordinateSystem.DrawIsoline(g, _strokePen, ll, lm); } else if (lhvalid) { layer.CoordinateSystem.DrawIsoline(g, _strokePen, lm, lh); } // now the end bars if (_showEndBars) { if (lhvalid) { PointF outDir; layer.CoordinateSystem.GetNormalizedDirection(lm, lh, 1, new Logical3D(0, 1), out outDir); outDir.X *= _symbolSize / 2; outDir.Y *= _symbolSize / 2; double xlay, ylay; layer.CoordinateSystem.LogicalToLayerCoordinates(lh, out xlay, out ylay); // Draw a line from x,y to g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y)); } if (llvalid) { PointF outDir; layer.CoordinateSystem.GetNormalizedDirection(lm, ll, 1, new Logical3D(0, 1), out outDir); outDir.X *= _symbolSize / 2; outDir.Y *= _symbolSize / 2; double xlay, ylay; layer.CoordinateSystem.LogicalToLayerCoordinates(ll, out xlay, out ylay); // Draw a line from x,y to g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y)); } } } } g.Clip = oldClippingRegion; }
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata) { PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) { _skipFreq = 1; } // paint the drop style if (this.DropLine.Count > 0) { foreach (CSPlaneID id in _dropLine) { layer.UpdateCSPlaneID(id); } int rangeidx = 0; PlotRange range = pdata.RangeList[rangeidx]; for (int j = 0; j < ptArray.Length; j += _skipFreq) { // syncronize range while (j >= range.UpperBound) { rangeidx++; range = pdata.RangeList[rangeidx]; } Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal); foreach (CSPlaneID id in _dropLine) { layer.CoordinateSystem.DrawIsolineFromPointToPlane(g, this._pen, r3d, id); } } } // end paint the drop style // paint the scatter style if (this.Shape != XYPlotScatterStyles.Shape.NoSymbol) { // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); float xpos = 0, ypos = 0; float xdiff, ydiff; for (int j = 0; j < ptArray.Length; j += _skipFreq) { xdiff = ptArray[j].X - xpos; ydiff = ptArray[j].Y - ypos; xpos = ptArray[j].X; ypos = ptArray[j].Y; g.TranslateTransform(xdiff, ydiff); this.Paint(g); } // end for g.Restore(gs); // Restore the graphics state } }
/// <inheritdoc/> public override void FillOneRange( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, bool ignoreMissingDataPoints, bool connectCircular, PointF[] allLinePointsShiftedAlready, double logicalShiftX, double logicalShiftY ) { if (range.Length < 2) return; int lastIdx; PointF[] linePoints = Segment2Connection_GetSubPoints(allLinePointsShiftedAlready, range, layer, connectCircular, out lastIdx); if (connectCircular) { gp.AddLines(linePoints); gp.CloseFigure(); } else { int offs = range.LowerBound; for (int i = 0; i < linePoints.Length - 1; i += 2) { Logical3D r0 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i)); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddLine(linePoints[i].X, linePoints[i].Y, linePoints[i + 1].X, linePoints[i + 1].Y); Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + i + 1)); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.StartFigure(); } gp.CloseFigure(); } }
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); } } }
private void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { // adjust the skip frequency if it was not set appropriate if (_skipFrequency <= 0) { _skipFrequency = 1; } var dropTargets = new List <CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id))); if (_additionalDropTargetIsEnabled) { CSPlaneID userPlane; if (_additionalDropTargetUsePhysicalBaseValue) { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue)); } else { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue); } dropTargets.Add(userPlane); } // paint the scatter style PointD3D pos = PointD3D.Empty; var gpath = new GraphicsPath(); if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color { // update pen widths var pen = _pen.Clone(); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; pen.Width = w1; var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; foreach (CSPlaneID id in dropTargets) { gpath.Reset(); layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id); PointF[] shortenedPathPoints = null; if (gapStart != 0 || gapEnd != 0) { gpath.Flatten(); var pathPoints = gpath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != shortenedPathPoints) { g.DrawLines(pen, shortenedPathPoints); } } else { g.DrawPath(pen, gpath); } } } } else // using a variable symbol size or variable symbol color { int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); var pen = _pen.Clone(); if (null == _cachedColorForIndexFunction) { _cachedSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; pen.Width = w1; } else { _cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; var customSymbolColor = _cachedColorForIndexFunction(originalRowIndex); pen.Width = w1; pen.Color = NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B); } var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; foreach (CSPlaneID id in _dropTargets) { gpath.Reset(); layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id); PointF[] shortenedPathPoints = null; if (gapStart != 0 || gapEnd != 0) { gpath.Flatten(); var pathPoints = gpath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != shortenedPathPoints) { g.DrawLines(pen, shortenedPathPoints); } } else { g.DrawPath(pen, gpath); } } } } }
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData) { PlotRangeList rangeList = pdata.RangeList; var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) { _skipFreq = 1; } var dropTargets = new List <CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id))); if (_additionalDropTargetIsEnabled) { CSPlaneID userPlane; if (_additionalDropTargetUsePhysicalBaseValue) { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue)); } else { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue); } dropTargets.Add(userPlane); } // paint the scatter style PointD3D pos = PointD3D.Empty; if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color { var pen = _pen; // update pen widths double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; pen = pen.WithThickness1(w1).WithThickness2(w2); var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); for (int r = 0; r < rangeList.Count; r++) { var range = rangeList[r]; int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFreq) { Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal); foreach (CSPlaneID id in dropTargets) { layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out var isoLine); if (gapStart != 0 || gapEnd != 0) { isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); } if (null != isoLine) { g.DrawLine(pen, isoLine); } } } } // for each range } else // using a variable symbol size or variable symbol color { for (int r = 0; r < rangeList.Count; r++) { var range = rangeList[r]; int lower = range.LowerBound; int upper = range.UpperBound; int offset = range.OffsetToOriginal; for (int j = lower; j < upper; j += _skipFreq) { var pen = _pen; if (null == _cachedColorForIndexFunction) { _cachedSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; pen = _pen.WithThickness1(w1).WithThickness2(w2); } else { _cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(j + offset); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; var customSymbolColor = _cachedColorForIndexFunction(j + offset); pen = _pen.WithThickness1(w1).WithThickness2(w2).WithColor(NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B)); } var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); Logical3D r3d = layer.GetLogical3D(pdata, j + rangeList[r].OffsetToOriginal); foreach (CSPlaneID id in _dropTargets) { layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out var isoLine); if (gapStart != 0 || gapEnd != 0) { isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); } if (null != isoLine) { g.DrawLine(pen, isoLine); } } } } } }
private void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { // adjust the skip frequency if it was not set appropriate if (_skipFrequency <= 0) _skipFrequency = 1; var dropTargets = new List<CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id))); if (_additionalDropTargetIsEnabled) { CSPlaneID userPlane; if (_additionalDropTargetUsePhysicalBaseValue) { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue)); } else { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue); } dropTargets.Add(userPlane); } // paint the scatter style PointD3D pos = PointD3D.Empty; var gpath = new GraphicsPath(); if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color { // update pen widths var pen = _pen.Clone(); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; pen.Width = w1; var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; foreach (CSPlaneID id in dropTargets) { gpath.Reset(); layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id); PointF[] shortenedPathPoints = null; if (gapStart != 0 || gapEnd != 0) { gpath.Flatten(); var pathPoints = gpath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != shortenedPathPoints) g.DrawLines(pen, shortenedPathPoints); } else { g.DrawPath(pen, gpath); } } } } else // using a variable symbol size or variable symbol color { int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFrequency) { var originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); var pen = _pen.Clone(); if (null == _cachedColorForIndexFunction) { _cachedSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; pen.Width = w1; } else { _cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(originalRowIndex); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; var customSymbolColor = _cachedColorForIndexFunction(originalRowIndex); pen.Width = w1; pen.Color = NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B); } var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; foreach (CSPlaneID id in _dropTargets) { gpath.Reset(); layer.CoordinateSystem.GetIsolineFromPointToPlane(gpath, r3d, id); PointF[] shortenedPathPoints = null; if (gapStart != 0 || gapEnd != 0) { gpath.Flatten(); var pathPoints = gpath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != shortenedPathPoints) g.DrawLines(pen, shortenedPathPoints); } else { g.DrawPath(pen, gpath); } } } } }
public void Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata) { if (this._labelColumn.Document == null) { return; } if (null != _attachedPlane) { layer.UpdateCSPlaneID(_attachedPlane); } PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; Altaxo.Data.IReadableColumn labelColumn = this._labelColumn.Document; // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); /* * double bottomPosition = 0; * double topPosition = 0; * double leftPosition = 0; * double rightPosition = 0; * * layer.CoordinateSystem.LogicalToLayerCoordinates(0, 0, out leftPosition, out bottomPosition); * layer.CoordinateSystem.LogicalToLayerCoordinates(1, 1, out rightPosition, out topPosition); */ double xpos = 0, ypos = 0; double xpre, ypre; double xdiff, ydiff; for (int r = 0; r < rangeList.Count; r++) { int lower = rangeList[r].LowerBound; int upper = rangeList[r].UpperBound; int offset = rangeList[r].OffsetToOriginal; for (int j = lower; j < upper; j++) { string label = labelColumn[j + offset].ToString(); if (label == null || label == string.Empty) { continue; } xpre = ptArray[j].X; ypre = ptArray[j].Y; if (null != this._attachedPlane) { Logical3D r3d = layer.GetLogical3D(pdata, j + offset); PointF pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d); xpre = pp.X; ypre = pp.Y; } xdiff = xpre - xpos; ydiff = ypre - ypos; xpos = xpre; ypos = ypre; g.TranslateTransform((float)xdiff, (float)ydiff); if (this._rotation != 0) { g.RotateTransform((float)-this._rotation); } this.Paint(g, label); if (this._rotation != 0) { g.RotateTransform((float)this._rotation); } } // end for } g.Restore(gs); // Restore the graphics state }
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData) { const double logicalClampMinimum = -10; const double logicalClampMaximum = 11; // Plot error bars for the dependent variable (y) PlotRangeList rangeList = pdata.RangeList; var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; var columnX = ColumnX; var columnY = ColumnY; var columnZ = ColumnZ; if (columnX == null || columnY == null || columnZ == null) return; // nothing to do if both error columns are null if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType) || !typeof(double).IsAssignableFrom(columnZ.ItemType)) return; // TODO make this an runtime paint error to be reported var strokePen = _strokePen; foreach (PlotRange r in rangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; j += _skipFrequency) { int originalRow = j + offset; double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRow); strokePen = strokePen.WithThickness1(_lineWidth1Offset + _lineWidth1Factor * symbolSize); strokePen = strokePen.WithThickness2(_lineWidth2Offset + _lineWidth2Factor * symbolSize); if (null != _cachedColorForIndexFunction) strokePen = strokePen.WithColor(GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRow), "VariableColor")); if (null != strokePen.LineEndCap) strokePen = strokePen.WithLineEndCap(strokePen.LineEndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6)); // Calculate target AltaxoVariant targetX, targetY, targetZ; switch (_meaningOfValues) { case ValueInterpretation.AbsoluteDifference: { targetX = pdata.GetXPhysical(originalRow) + columnX[originalRow]; targetY = pdata.GetYPhysical(originalRow) + columnY[originalRow]; targetZ = pdata.GetZPhysical(originalRow) + columnZ[originalRow]; } break; case ValueInterpretation.AbsoluteValue: { targetX = columnX[originalRow]; targetY = columnY[originalRow]; targetZ = columnZ[originalRow]; } break; default: throw new NotImplementedException(nameof(_meaningOfValues)); } var logicalTarget = layer.GetLogical3D(targetX, targetY, targetZ); var logicalOrigin = layer.GetLogical3D(pdata, originalRow); if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ)) { logicalOrigin.RX += _cachedLogicalShiftX; logicalOrigin.RY += _cachedLogicalShiftY; logicalOrigin.RZ += _cachedLogicalShiftZ; logicalTarget.RX += _cachedLogicalShiftX; logicalTarget.RY += _cachedLogicalShiftY; logicalTarget.RZ += _cachedLogicalShiftZ; } 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; var isoLine = layer.CoordinateSystem.GetIsoline(logicalOrigin, logicalTarget); if (null == isoLine) continue; if (_useManualVectorLength) { double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize; double isoLineLength = isoLine.TotalLineLength; isoLine = isoLine.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length)); if (null == isoLine) continue; } if (_useSymbolGap) { double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap != 0) { isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); if (null == isoLine) continue; } } g.DrawLine(strokePen, isoLine); } } }
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData) { PlotRangeList rangeList = pdata.RangeList; var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; // adjust the skip frequency if it was not set appropriate if (_skipFreq <= 0) _skipFreq = 1; var dropTargets = new List<CSPlaneID>(_dropTargets.Select(id => layer.UpdateCSPlaneID(id))); if (_additionalDropTargetIsEnabled) { CSPlaneID userPlane; if (_additionalDropTargetUsePhysicalBaseValue) { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, layer.Scales[_additionalDropTargetPerpendicularAxis].PhysicalVariantToNormal(_additionalDropTargetBaseValue)); } else { userPlane = new CSPlaneID(_additionalDropTargetPerpendicularAxis, _additionalDropTargetBaseValue); } dropTargets.Add(userPlane); } // paint the scatter style PointD3D pos = PointD3D.Empty; if (null == _cachedSymbolSizeForIndexFunction && null == _cachedColorForIndexFunction) // using a constant symbol size and constant color { var pen = _pen; // update pen widths double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; pen = pen.WithThickness1(w1).WithThickness2(w2); var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); for (int r = 0; r < rangeList.Count; r++) { var range = rangeList[r]; int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j += _skipFreq) { Logical3D r3d = layer.GetLogical3D(pdata, j + range.OffsetToOriginal); foreach (CSPlaneID id in dropTargets) { IPolylineD3D isoLine; layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out isoLine); if (gapStart != 0 || gapEnd != 0) isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != isoLine) g.DrawLine(pen, isoLine); } } } // for each range } else // using a variable symbol size or variable symbol color { for (int r = 0; r < rangeList.Count; r++) { var range = rangeList[r]; int lower = range.LowerBound; int upper = range.UpperBound; int offset = range.OffsetToOriginal; for (int j = lower; j < upper; j += _skipFreq) { var pen = _pen; if (null == _cachedColorForIndexFunction) { _cachedSymbolSize = _cachedSymbolSizeForIndexFunction(j + offset); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; pen = _pen.WithThickness1(w1).WithThickness2(w2); } else { _cachedSymbolSize = null == _cachedSymbolSizeForIndexFunction ? _cachedSymbolSize : _cachedSymbolSizeForIndexFunction(j + offset); double w1 = _lineWidth1Offset + _lineWidth1Factor * _cachedSymbolSize; double w2 = _lineWidth2Offset + _lineWidth2Factor * _cachedSymbolSize; var customSymbolColor = _cachedColorForIndexFunction(j + offset); pen = _pen.WithThickness1(w1).WithThickness2(w2).WithColor(NamedColor.FromArgb(customSymbolColor.A, customSymbolColor.R, customSymbolColor.G, customSymbolColor.B)); } var gapStart = 0.5 * (_gapAtStartOffset + _gapAtStartFactor * _cachedSymbolSize); var gapEnd = 0.5 * (_gapAtEndOffset + _gapAtEndFactor * _cachedSymbolSize); Logical3D r3d = layer.GetLogical3D(pdata, j + rangeList[r].OffsetToOriginal); foreach (CSPlaneID id in _dropTargets) { IPolylineD3D isoLine; layer.CoordinateSystem.GetIsolineFromPointToPlane(r3d, id, out isoLine); if (gapStart != 0 || gapEnd != 0) isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gapStart), RADouble.NewAbs(gapEnd)); if (null != isoLine) g.DrawLine(pen, isoLine); } } } } }
public void PaintOneRange(Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { if (this._labelColumnProxy.Document == null) return; _cachedStringFormat.Alignment = GdiExtensionMethods.ToGdi(_alignmentX); _cachedStringFormat.LineAlignment = GdiExtensionMethods.ToGdi(_alignmentY); if (null != _attachedPlane) _attachedPlane = layer.UpdateCSPlaneID(_attachedPlane); var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; Altaxo.Data.IReadableColumn labelColumn = this._labelColumnProxy.Document; bool isUsingVariableColorForLabelText = null != _cachedColorForIndexFunction && IsColorReceiver; bool isUsingVariableColorForLabelBackground = null != _cachedColorForIndexFunction && (null != _backgroundStyle && _backgroundStyle.SupportsBrush && (_backgroundColorLinkage == ColorLinkage.Dependent || _backgroundColorLinkage == ColorLinkage.PreserveAlpha)); bool isUsingVariableColor = isUsingVariableColorForLabelText || isUsingVariableColorForLabelBackground; BrushX clonedTextBrush = null; BrushX clonedBackBrush = null; if (isUsingVariableColorForLabelText) clonedTextBrush = _brush.Clone(); if (isUsingVariableColorForLabelBackground) clonedBackBrush = _backgroundStyle.Brush.Clone(); // save the graphics stat since we have to translate the origin var gs = g.Save(); double xpos = 0, ypos = 0; double xpre, ypre; double xdiff, ydiff; bool isFormatStringContainingBraces = _labelFormatString?.IndexOf('{') >= 0; var culture = System.Threading.Thread.CurrentThread.CurrentCulture; bool mustUseLogicalCoordinates = null != this._attachedPlane || 0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY; int lower = range.LowerBound; int upper = range.UpperBound; for (int j = lower; j < upper; j+=_skipFrequency) { int originalRowIndex = range.GetOriginalRowIndexFromPlotPointIndex(j); string label; if (string.IsNullOrEmpty(_labelFormatString)) { label = labelColumn[originalRowIndex].ToString(); } else if (!isFormatStringContainingBraces) { label = labelColumn[originalRowIndex].ToString(_labelFormatString, culture); } else { // the label format string can contain {0} for the label column item, {1} for the row index, {2} .. {4} for the x, y and z component of the data point label = string.Format(_labelFormatString, labelColumn[originalRowIndex], originalRowIndex, pdata.GetPhysical(0, originalRowIndex), pdata.GetPhysical(1, originalRowIndex), pdata.GetPhysical(2, originalRowIndex)); } if (string.IsNullOrEmpty(label)) continue; double localSymbolSize = _symbolSize; if (null != _cachedSymbolSizeForIndexFunction) { localSymbolSize = _cachedSymbolSizeForIndexFunction(originalRowIndex); } double localFontSize = _fontSizeOffset + _fontSizeFactor * localSymbolSize; if (!(localFontSize > 0)) continue; _font = _font.WithSize(localFontSize); // Start of preparation of brushes, if a variable color is used if (isUsingVariableColor) { Color c = _cachedColorForIndexFunction(originalRowIndex); if (isUsingVariableColorForLabelText) { clonedTextBrush.Color = new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e"); } if (isUsingVariableColorForLabelBackground) { if (_backgroundColorLinkage == ColorLinkage.PreserveAlpha) clonedBackBrush.Color = new NamedColor(AxoColor.FromArgb(clonedBackBrush.Color.Color.A, c.R, c.G, c.B), "e"); else clonedBackBrush.Color = new NamedColor(AxoColor.FromArgb(c.A, c.R, c.G, c.B), "e"); } } // end of preparation of brushes for variable colors if (mustUseLogicalCoordinates) // we must use logical coordinates because either there is a shift of logical coordinates, or an attached plane { Logical3D r3d = layer.GetLogical3D(pdata, originalRowIndex); r3d.RX += _cachedLogicalShiftX; r3d.RY += _cachedLogicalShiftY; if (null != this._attachedPlane) { var pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane, r3d); xpre = pp.X; ypre = pp.Y; } else { PointD3D pt; layer.CoordinateSystem.LogicalToLayerCoordinates(r3d, out xpre, out ypre); } } else // no shifting, thus we can use layer coordinates { xpre = ptArray[j].X; ypre = ptArray[j].Y; } xdiff = xpre - xpos; ydiff = ypre - ypos; xpos = xpre; ypos = ypre; g.TranslateTransform((float)xdiff, (float)ydiff); if (this._rotation != 0) g.RotateTransform((float)-this._rotation); this.PaintOneItem(g, label, localSymbolSize, clonedTextBrush, clonedBackBrush); if (this._rotation != 0) g.RotateTransform((float)this._rotation); } g.Restore(gs); // Restore the graphics state }
protected void PaintOneRange(int axisNumber, Graphics g, IPlotArea layer, IPlotRange range, Processed2DPlotData pdata) { const double logicalClampMinimum = -10; const double logicalClampMaximum = 11; _skipFrequency = Math.Max(1, _skipFrequency); // Plot error bars for the dependent variable (y) var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; var posErrCol = PositiveErrorColumn; var negErrCol = NegativeErrorColumn; if (null != posErrCol && !typeof(double).IsAssignableFrom(posErrCol.ItemType)) posErrCol = null; // TODO make this an runtime paint error to be reported if (null != negErrCol && !typeof(double).IsAssignableFrom(negErrCol.ItemType)) negErrCol = null; // TODO make this an runtime paint error to be reported if (posErrCol == null && negErrCol == null) return; // nothing to do if both error columns are null var strokePen = _pen.Clone(); System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath(); Region oldClippingRegion = g.Clip; Region newClip = (Region)oldClippingRegion.Clone(); 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 (null != strokePen.EndCap) strokePen.EndCap = strokePen.EndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6); AltaxoVariant vMeanPhysical = pdata.GetPhysical(axisNumber, originalRowIndex); Logical3D logicalMean = layer.GetLogical3D(pdata, originalRowIndex); logicalMean.RX += _cachedLogicalShiftX; logicalMean.RY += _cachedLogicalShiftY; if (!Calc.RMath.IsInIntervalCC(logicalMean.RX, logicalClampMinimum, logicalClampMaximum)) continue; if (!Calc.RMath.IsInIntervalCC(logicalMean.RY, logicalClampMinimum, logicalClampMaximum)) continue; var vMeanLogical = logicalMean.GetR(axisNumber); Logical3D logicalPos = logicalMean; Logical3D logicalNeg = logicalMean; bool logicalPosValid = false; bool logicalNegValid = false; switch (_meaningOfValues) { case ValueInterpretation.AbsoluteError: { if (posErrCol != null) { var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical + Math.Abs(posErrCol[originalRowIndex])); vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum); logicalPos.SetR(axisNumber, vPosLogical); logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical; } if (negErrCol != null) { var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical - Math.Abs(negErrCol[originalRowIndex])); vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum); logicalNeg.SetR(axisNumber, vNegLogical); logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical; } } break; case ValueInterpretation.RelativeError: { if (posErrCol != null) { var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical * (1 + Math.Abs(posErrCol[originalRowIndex]))); vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum); logicalPos.SetR(axisNumber, vPosLogical); logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical; } if (negErrCol != null) { var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(vMeanPhysical * (1 - Math.Abs(negErrCol[originalRowIndex]))); vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum); logicalNeg.SetR(axisNumber, vNegLogical); logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical; } } break; case ValueInterpretation.AbsoluteValue: { if (posErrCol != null) { var vPosLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(posErrCol[originalRowIndex]); vPosLogical = Calc.RMath.ClampToInterval(vPosLogical, logicalClampMinimum, logicalClampMaximum); logicalPos.SetR(axisNumber, vPosLogical); logicalPosValid = !logicalPos.IsNaN && vPosLogical != vMeanLogical; } if (negErrCol != null) { var vNegLogical = layer.Scales[axisNumber].PhysicalVariantToNormal(negErrCol[originalRowIndex]); vNegLogical = Calc.RMath.ClampToInterval(vNegLogical, logicalClampMinimum, logicalClampMaximum); logicalNeg.SetR(axisNumber, vNegLogical); logicalNegValid = !logicalNeg.IsNaN && vNegLogical != vMeanLogical; } if (object.ReferenceEquals(negErrCol, posErrCol)) { logicalNegValid = false; // then we need only to plot the positive column, since both colums are identical } } break; } // end switch if (!(logicalPosValid || logicalNegValid)) continue; // nothing to do for this point if both pos and neg logical point are invalid. if (logicalNegValid) { errorBarPath.Reset(); layer.CoordinateSystem.GetIsoline(errorBarPath, logicalMean, logicalNeg); PointF[] shortenedPathPoints = null; bool shortenedPathPointsCalculated = false; if (_useSymbolGap) { double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap > 0) { errorBarPath.Flatten(); var pathPoints = errorBarPath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); shortenedPathPointsCalculated = true; if (null == shortenedPathPoints && _forceVisibilityOfEndCap && !(strokePen.EndCap is Altaxo.Graph.Gdi.LineCaps.FlatCap)) { var totalLineLength = GdiExtensionMethods.TotalLineLength(pathPoints); var shortTheLineBy = Math.Max(0, totalLineLength - 0.125 * strokePen.Width); shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(shortTheLineBy), RADouble.NewAbs(0)); } } } if (shortenedPathPointsCalculated) { if (null != shortenedPathPoints) { g.DrawLines(strokePen, shortenedPathPoints); } } else { g.DrawPath(strokePen, errorBarPath); } } if (logicalPosValid) { errorBarPath.Reset(); layer.CoordinateSystem.GetIsoline(errorBarPath, logicalMean, logicalPos); PointF[] shortenedPathPoints = null; bool shortenedPathPointsCalculated = false; if (_useSymbolGap) { double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap > 0) { errorBarPath.Flatten(); var pathPoints = errorBarPath.PathPoints; shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); shortenedPathPointsCalculated = true; if (null == shortenedPathPoints && _forceVisibilityOfEndCap && !(strokePen.EndCap is Altaxo.Graph.Gdi.LineCaps.FlatCap)) { var totalLineLength = GdiExtensionMethods.TotalLineLength(pathPoints); var shortTheLineBy = Math.Max(0, totalLineLength - 0.125 * strokePen.Width); shortenedPathPoints = GdiExtensionMethods.ShortenedBy(pathPoints, RADouble.NewAbs(shortTheLineBy), RADouble.NewAbs(0)); } } } if (shortenedPathPointsCalculated) { if (null != shortenedPathPoints) { g.DrawLines(strokePen, shortenedPathPoints); } } else { g.DrawPath(strokePen, errorBarPath); } } } g.Clip = oldClippingRegion; }
/// <inheritdoc/> public override void FillOneRange( GraphicsPath gp, Processed2DPlotData pdata, IPlotRange range, IPlotArea layer, CSPlaneID fillDirection, bool ignoreMissingDataPoints, bool connectCircular, PointF[] allLinePoints, double logicalShiftX, double logicalShiftY ) { PointF[] circularLinePoints = new PointF[range.Length + (connectCircular ? 1 : 0)]; Array.Copy(allLinePoints, range.LowerBound, circularLinePoints, 0, range.Length); // Extract if (connectCircular) circularLinePoints[circularLinePoints.Length - 1] = circularLinePoints[0]; if (connectCircular) { gp.AddLines(circularLinePoints); gp.CloseFigure(); } else // not circular { Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint); r0.RX += logicalShiftX; r0.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0); gp.AddLines(circularLinePoints); Logical3D r1 = layer.GetLogical3D(pdata, connectCircular ? range.OriginalFirstPoint : range.OriginalLastPoint); r1.RX += logicalShiftX; r1.RY += logicalShiftY; layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection); layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0); gp.CloseFigure(); } }
protected void PaintXErrorBars(System.Drawing.Graphics g, IPlotArea layer, Altaxo.Graph.Gdi.Plot.Data.Processed2DPlotData pdata) { // Plot error bars for the independent variable (x) PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; INumericColumn posErrCol = _positiveErrorColumn.Document; INumericColumn negErrCol = _negativeErrorColumn.Document; if (posErrCol == null && negErrCol == null) return; // nothing to do if both error columns are null System.Drawing.Drawing2D.GraphicsPath errorBarPath = new System.Drawing.Drawing2D.GraphicsPath(); Region oldClippingRegion = g.Clip; Region newClip = (Region)oldClippingRegion.Clone(); foreach (PlotRange r in rangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; j++) { AltaxoVariant x = pdata.GetXPhysical(j + offset); Logical3D lm = layer.GetLogical3D(pdata, j + offset); lm.RX += _cachedLogicalShiftOfIndependent; if (lm.IsNaN) continue; Logical3D lh = lm; Logical3D ll = lm; bool lhvalid = false; bool llvalid = false; if (posErrCol != null) { lh.RX = layer.XAxis.PhysicalVariantToNormal(x + Math.Abs(posErrCol[j + offset])); lhvalid = !lh.IsNaN; } if (negErrCol != null) { ll.RX = layer.XAxis.PhysicalVariantToNormal(x - Math.Abs(negErrCol[j + offset])); llvalid = !ll.IsNaN; } if (!(lhvalid || llvalid)) continue; // nothing to do for this point if both pos and neg logical point are invalid. // now paint the error bar if (_symbolGap) // if symbol gap, then clip the painting, exclude a rectangle of size symbolSize x symbolSize { double xlm, ylm; layer.CoordinateSystem.LogicalToLayerCoordinates(lm, out xlm, out ylm); newClip.Union(oldClippingRegion); newClip.Exclude(new RectangleF((float)(xlm - _symbolSize / 2), (float)(ylm - _symbolSize / 2), _symbolSize, _symbolSize)); g.Clip = newClip; } if (lhvalid && llvalid) { errorBarPath.Reset(); layer.CoordinateSystem.GetIsoline(errorBarPath, ll, lm); layer.CoordinateSystem.GetIsoline(errorBarPath, lm, lh); g.DrawPath(_strokePen, errorBarPath); } else if (llvalid) { layer.CoordinateSystem.DrawIsoline(g, _strokePen, ll, lm); } else if (lhvalid) { layer.CoordinateSystem.DrawIsoline(g, _strokePen, lm, lh); } // now the end bars if (_showEndBars) { if (lhvalid) { PointF outDir; layer.CoordinateSystem.GetNormalizedDirection(lm, lh, 1, new Logical3D(0, 1), out outDir); outDir.X *= _symbolSize / 2; outDir.Y *= _symbolSize / 2; double xlay, ylay; layer.CoordinateSystem.LogicalToLayerCoordinates(lh, out xlay, out ylay); // Draw a line from x,y to g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y)); } if (llvalid) { PointF outDir; layer.CoordinateSystem.GetNormalizedDirection(lm, ll, 1, new Logical3D(0, 1), out outDir); outDir.X *= _symbolSize / 2; outDir.Y *= _symbolSize / 2; double xlay, ylay; layer.CoordinateSystem.LogicalToLayerCoordinates(ll, out xlay, out ylay); // Draw a line from x,y to g.DrawLine(_strokePen, (float)(xlay - outDir.X), (float)(ylay - outDir.Y), (float)(xlay + outDir.X), (float)(ylay + outDir.Y)); } } } } g.Clip = oldClippingRegion; }
public void Paint(IGraphicsContext3D g, IPlotArea layer, Processed3DPlotData pdata, Processed3DPlotData prevItemData, Processed3DPlotData nextItemData) { const double logicalClampMinimum = -10; const double logicalClampMaximum = 11; // Plot error bars for the dependent variable (y) PlotRangeList rangeList = pdata.RangeList; var ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; var columnX = ColumnX; var columnY = ColumnY; var columnZ = ColumnZ; if (columnX == null || columnY == null || columnZ == null) { return; // nothing to do if both error columns are null } if (!typeof(double).IsAssignableFrom(columnX.ItemType) || !typeof(double).IsAssignableFrom(columnY.ItemType) || !typeof(double).IsAssignableFrom(columnZ.ItemType)) { return; // TODO make this an runtime paint error to be reported } var strokePen = _strokePen; foreach (PlotRange r in rangeList) { int lower = r.LowerBound; int upper = r.UpperBound; int offset = r.OffsetToOriginal; for (int j = lower; j < upper; j += _skipFrequency) { int originalRow = j + offset; double symbolSize = null == _cachedSymbolSizeForIndexFunction ? _symbolSize : _cachedSymbolSizeForIndexFunction(originalRow); strokePen = strokePen.WithThickness1(_lineWidth1Offset + _lineWidth1Factor * symbolSize); strokePen = strokePen.WithThickness2(_lineWidth2Offset + _lineWidth2Factor * symbolSize); if (null != _cachedColorForIndexFunction) { strokePen = strokePen.WithColor(GdiColorHelper.ToNamedColor(_cachedColorForIndexFunction(originalRow), "VariableColor")); } if (null != strokePen.LineEndCap) { strokePen = strokePen.WithLineEndCap(strokePen.LineEndCap.WithMinimumAbsoluteAndRelativeSize(symbolSize * _endCapSizeFactor + _endCapSizeOffset, 1 + 1E-6)); } // Calculate target AltaxoVariant targetX, targetY, targetZ; switch (_meaningOfValues) { case ValueInterpretation.AbsoluteDifference: { targetX = pdata.GetXPhysical(originalRow) + columnX[originalRow]; targetY = pdata.GetYPhysical(originalRow) + columnY[originalRow]; targetZ = pdata.GetZPhysical(originalRow) + columnZ[originalRow]; } break; case ValueInterpretation.AbsoluteValue: { targetX = columnX[originalRow]; targetY = columnY[originalRow]; targetZ = columnZ[originalRow]; } break; default: throw new NotImplementedException(nameof(_meaningOfValues)); } var logicalTarget = layer.GetLogical3D(targetX, targetY, targetZ); var logicalOrigin = layer.GetLogical3D(pdata, originalRow); if (!_independentOnShiftingGroupStyles && (0 != _cachedLogicalShiftX || 0 != _cachedLogicalShiftY || 0 != _cachedLogicalShiftZ)) { logicalOrigin.RX += _cachedLogicalShiftX; logicalOrigin.RY += _cachedLogicalShiftY; logicalOrigin.RZ += _cachedLogicalShiftZ; logicalTarget.RX += _cachedLogicalShiftX; logicalTarget.RY += _cachedLogicalShiftY; logicalTarget.RZ += _cachedLogicalShiftZ; } 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; } var isoLine = layer.CoordinateSystem.GetIsoline(logicalOrigin, logicalTarget); if (null == isoLine) { continue; } if (_useManualVectorLength) { double length = _vectorLengthOffset + _vectorLengthFactor * symbolSize; double isoLineLength = isoLine.TotalLineLength; isoLine = isoLine.ShortenedBy(RADouble.NewAbs(0), RADouble.NewAbs(isoLineLength - length)); if (null == isoLine) { continue; } } if (_useSymbolGap) { double gap = _symbolGapOffset + _symbolGapFactor * symbolSize; if (gap != 0) { isoLine = isoLine.ShortenedBy(RADouble.NewAbs(gap / 2), RADouble.NewAbs(0)); if (null == isoLine) { continue; } } } g.DrawLine(strokePen, isoLine); } } }
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 Paint(Graphics g, IPlotArea layer, Processed2DPlotData pdata) { if (this._labelColumn.Document == null) return; if (null != _attachedPlane) layer.UpdateCSPlaneID(_attachedPlane); PlotRangeList rangeList = pdata.RangeList; PointF[] ptArray = pdata.PlotPointsInAbsoluteLayerCoordinates; Altaxo.Data.IReadableColumn labelColumn = this._labelColumn.Document; // save the graphics stat since we have to translate the origin System.Drawing.Drawing2D.GraphicsState gs = g.Save(); /* double bottomPosition = 0; double topPosition = 0; double leftPosition = 0; double rightPosition = 0; layer.CoordinateSystem.LogicalToLayerCoordinates(0, 0, out leftPosition, out bottomPosition); layer.CoordinateSystem.LogicalToLayerCoordinates(1, 1, out rightPosition, out topPosition); */ double xpos = 0, ypos = 0; double xpre, ypre; double xdiff, ydiff; for (int r = 0; r < rangeList.Count; r++) { int lower = rangeList[r].LowerBound; int upper = rangeList[r].UpperBound; int offset = rangeList[r].OffsetToOriginal; for (int j = lower; j < upper; j++) { string label = labelColumn[j + offset].ToString(); if (label == null || label == string.Empty) continue; xpre = ptArray[j].X; ypre = ptArray[j].Y; if (null!=this._attachedPlane) { Logical3D r3d = layer.GetLogical3D(pdata, j + offset); PointF pp = layer.CoordinateSystem.GetPointOnPlane(this._attachedPlane,r3d); xpre = pp.X; ypre = pp.Y; } xdiff = xpre - xpos; ydiff = ypre - ypos; xpos = xpre; ypos = ypre; g.TranslateTransform((float)xdiff, (float)ydiff); if (this._rotation != 0) g.RotateTransform((float)-this._rotation); this.Paint(g, label); if (this._rotation != 0) g.RotateTransform((float)this._rotation); } // end for } g.Restore(gs); // Restore the graphics state }